_ncs.dp.md

Python _ncs.dp Module

Low level callback module for connecting data providers to NCS.

This module is used to connect to the NCS Data Provider API. The purpose of this API is to provide callback hooks so that user-written data providers can provide data stored externally to NCS. NCS needs this information in order to drive its northbound agents.

The module is also used to populate items in the data model which are not data or configuration items, such as statistics items from the device.

The module consists of a number of API functions whose purpose is to install different callback functions at different points in the data model tree which is the representation of the device configuration. Read more about callpoints in tailf_yang_extensions(5). Read more about how to use the module in the User Guide chapters on Operational data and External data.

This documentation should be read together with the confd_lib_dp(3) man page.

Functions

aaa_reload

aaa_reload(tctx) -> None

When the ConfD AAA tree is populated by an external data provider (see the AAA chapter in the User Guide), this function can be used by the data provider to notify ConfD when there is a change to the AAA data.

Keyword arguments:

• tctx -- a transaction context

access_reply_result

access_reply_result(actx, result) -> None

The callbacks must call this function to report the result of the access check to ConfD, and should normally return CONFD_OK. If any other value is returned, it will cause the access check to be rejected.

Keyword arguments:

• actx -- the authorization context
• result -- the result (ACCESS_RESULT_xxx)

action_delayed_reply_error

action_delayed_reply_error(uinfo, errstr) -> None

If we use the CONFD_DELAYED_RESPONSE as a return value from the action callback, we must later asynchronously reply. This function is used to reply with error.

Keyword arguments:

• uinfo -- a user info context
• errstr -- an error string

action_delayed_reply_ok

action_delayed_reply_ok(uinfo) -> None

If we use the CONFD_DELAYED_RESPONSE as a return value from the action callback, we must later asynchronously reply. This function is used to reply with success.

Keyword arguments:

• uinfo -- a user info context

action_reply_command

action_reply_command(uinfo, values) -> None

If a CLI callback command should return data, it must invoke this function in response to the cb_command() callback.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of strings or None

action_reply_completion

action_reply_completion(uinfo, values) -> None

This function must normally be called in response to the cb_completion() callback.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of 3-tuples or None (see below)

The values argument must be None or a list of 3-tuples where each tuple is built up like:

(type::int, value::string, extra::string)

The third item of the tuple (extra) may be set to None.

action_reply_range_enum

action_reply_range_enum(uinfo, values, keysize) -> None

This function must be called in response to the cb_completion() callback when it is invoked via a tailf:cli-custom-range-enumerator statement in the data model.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of keys as strings or None
• keysize -- number of keys for the list in the data model

The values argument is a flat list of keys. If the list in the data model specifies multiple keys this list is still flat. The keysize argument tells us how many keys to use for each list element. So the size of values should be a multiple of keysize.

action_reply_rewrite

action_reply_rewrite(uinfo, values, unhides) -> None

This function can be called instead of action_reply_command() as a response to a show path rewrite callback invocation.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of strings or None
• unhides -- a list of strings or None

action_reply_rewrite2

action_reply_rewrite2(uinfo, values, unhides, selects) -> None

This function can be called instead of action_reply_command() as a response to a show path rewrite callback invocation.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of strings or None
• unhides -- a list of strings or None
• selects -- a list of strings or None

action_reply_values

action_reply_values(uinfo, values) -> None

If the action definition specifies that the action should return data, it must invoke this function in response to the cb_action() callback.

Keyword arguments:

• uinfo -- a user info context
• values -- a list of _lib.TagValue instances or None

action_set_fd

action_set_fd(uinfo, sock) -> None

Associate a worker socket with the action. This function must be called in the action cb_init() callback.

Keyword arguments:

• uinfo -- a user info context
• sock -- a previously connected worker socket

A typical implementation of an action cb_init() callback looks like:

class ActionCallbacks(object):
    def __init__(self, workersock):
        self.workersock = workersock

    def cb_init(self, uinfo):
        dp.action_set_fd(uinfo, self.workersock)

action_set_timeout

action_set_timeout(uinfo, timeout_secs) -> None

Some action callbacks may require a significantly longer execution time than others, and this time may not even be possible to determine statically (e.g. a file download). In such cases the /confdConfig/capi/queryTimeout setting in confd.conf may be insufficient, and this function can be used to extend (or shorten) the timeout for the current callback invocation. The timeout is given in seconds from the point in time when the function is called.

Keyword arguments:

• uinfo -- a user info context
• timeout_secs -- timeout value

action_seterr

action_seterr(uinfo, errstr) -> None

If action callback encounters fatal problems that can not be expressed via the reply function, it may call this function with an appropriate message and return CONFD_ERR instead of CONFD_OK.

Keyword arguments:

• uinfo -- a user info context
• errstr -- an error message string

action_seterr_extended

action_seterr_extended(uninfo, code, apptag_ns, apptag_tag, errstr) -> None

This function can be used to provide more structured error information from an action callback.

Keyword arguments:

• uinfo -- a user info context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• errstr -- an error message string

action_seterr_extended_info

action_seterr_extended_info(uinfo, code, apptag_ns, apptag_tag,
                            error_info, errstr) -> None

This function can be used to provide structured error information in the same way as action_seterr_extended(), and additionally provide contents for the NETCONF element.

Keyword arguments:

• uinfo -- a user info context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• error_info -- a list of _lib.TagValue instances
• errstr -- an error message string

auth_seterr

auth_seterr(actx, errstr) -> None

This function is used by the application to set an error string.

This function can be used to provide a text message when the callback returns CONFD_ERR. If used when rejecting a successful authentication, the message will be logged in ConfD's audit log (otherwise a generic "rejected by application callback" message is logged).

Keyword arguments:

• actx -- the auth context
• errstr -- an error message string

authorization_set_timeout

authorization_set_timeout(actx, timeout_secs) -> None

The authorization callbacks are invoked on the daemon control socket, and as such are expected to complete quickly. However in case they send requests to a remote server, and such a request needs to be retried, this function can be used to extend the timeout for the current callback invocation. The timeout is given in seconds from the point in time when the function is called.

Keyword arguments:

• actx -- the authorization context
• timeout_secs -- timeout value

connect

connect(dx, sock, type, ip, port, path) -> None

Connects to the ConfD daemon. The socket instance provided via the 'sock' argument must be kept alive during the lifetime of the daemon context.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• sock -- a Python socket instance
• type -- the socket type (CONTROL_SOCKET or WORKER_SOCKET)
• ip -- the ip address if socket is AF_INET (optional)
• port -- the port if socket is AF_INET (optional)
• path -- a filename if socket is AF_UNIX (optional).

data_get_list_filter

data_get_list_filter(tctx) -> ListFilter

Get list filter from transaction context.

Keyword arguments:

• tctx -- a transaction context

data_reply_attrs

data_reply_attrs(tctx, attrs) -> None

This function is used by the cb_get_attrs() callback to return the requested attribute values.

Keyword arguments:

• tctx -- a transaction context
• attrs -- a list of _lib.AttrValue instances

data_reply_found

data_reply_found(tctx) -> None

This function is used by the cb_exists_optional() callback to indicate to ConfD that a node does exist.

Keyword arguments:

• tctx -- a transaction context

data_reply_next_key

data_reply_next_key(tctx, keys, next) -> None

This function is used by the cb_get_next() and cb_find_next() callbacks to return the next key.

Keyword arguments:

• tctx -- a transaction context
• keys -- a list of keys of _lib.Value for a list item (se below)
• next -- int value passed to the next invocation of cb_get_next() callback

A list may have mutiple key leafs specified in the data model. This is why the keys argument must be a list.

data_reply_next_object_array

data_reply_next_object_array(tctx, v, next) -> None

This function is used by the optional cb_get_next_object() and cb_find_next_object() callbacks to return an entire object including its keys. It combines the functions of data_reply_next_key() and data_reply_value_array().

Keyword arguments:

• tctx -- a transaction context
• v -- a list of _lib.Value instances
• next -- int value passed to the next invocation of cb_get_next() callback

data_reply_next_object_arrays

data_reply_next_object_arrays(tctx, objs, timeout_millisecs) -> None

This function is used by the optional cb_get_next_object() and cb_find_next_object() callbacks to return multiple objects including their keys, in _lib.Value form.

Keyword arguments:

• tctx -- a transaction context
• objs -- a list of tuples or None (see below)
• timeout_millisecs -- timeout value for ConfD's caching of returned data

The format of argument objs is list(tuple(list(_lib.Value), long)), or None to indicate end of list. Another way to indicate end of list is to include None as the first item in the 2-tuple last in the list.

E.g.:

V = _lib.Value
objs = [
         ( [ V(1), V(2) ], next1 ),
         ( [ V(3), V(4) ], next2 ),
         ( None, -1 )
       ]

data_reply_next_object_tag_value_array

data_reply_next_object_tag_value_array(tctx, tvs, next) -> None

This function is used by the optional cb_get_next_object() and cb_find_next_object() callbacks to return an entire object including its keys

Keyword arguments:

• tctx -- a transaction context
• tvs -- a list of _lib.TagValue instances or None
• next -- int value passed to the next invocation of cb_get_next_object() callback

data_reply_next_object_tag_value_arrays

data_reply_next_object_tag_value_arrays(tctx, objs, timeout_millisecs) -> None

This function is used by the optional cb_get_next_object() and cb_find_next_object() callbacks to return multiple objects including their keys.

Keyword arguments:

• tctx -- a transaction context
• objs -- a list of tuples or None (see below)
• timeout_millisecs -- timeout value for ConfD's caching of returned data

The format of argument objs is list(tuple(list(_lib.TagValue), long)) or None to indicate end of list. Another way to indicate end of list is to include None as the first item in the 2-tuple last in the list.

E.g.:

objs = [
         ( [ tagval1, tagval2 ], next1 ),
         ( [ tagval3, tagval4, tagval5 ], next2 ),
         ( None, -1 )
       ]

data_reply_not_found

data_reply_not_found(tctx) -> None

This function is used by the cb_get_elem() and cb_exists_optional() callbacks to indicate to ConfD that a list entry or node does not exist.

Keyword arguments:

• tctx -- a transaction context

data_reply_tag_value_array

data_reply_tag_value_array(tctx, tvs) -> None

This function is used to return an array of values, corresponding to a complete list entry, to ConfD. It can be used by the optional cb_get_object() callback.

Keyword arguments:

• tctx -- a transaction context
• tvs -- a list of _lib.TagValue instances or None

data_reply_value

data_reply_value(tctx, v) -> None

This function is used to return a single data item to ConfD.

Keyword arguments:

• tctx -- a transaction context
• v -- a _lib.Value instance

data_reply_value_array

data_reply_value_array(tctx, vs) -> None

This function is used to return an array of values, corresponding to a complete list entry, to ConfD. It can be used by the optional cb_get_object() callback.

Keyword arguments:

• tctx -- a transaction context
• vs -- a list of _lib.Value instances

data_set_timeout

data_set_timeout(tctx, timeout_secs) -> None

A data callback should normally complete quickly, since e.g. the execution of a 'show' command in the CLI may require many data callback invocations. In some rare cases it may still be necessary for a data callback to have a longer execution time, and then this function can be used to extend (or shorten) the timeout for the current callback invocation. The timeout is given in seconds from the point in time when the function is called.

Keyword arguments:

• tctx -- a transaction context
• timeout_secs -- timeout value

db_set_timeout

db_set_timeout(dbx, timeout_secs) -> None

Some of the DB callbacks registered via register_db_cb(), e.g. cb_copy_running_to_startup(), may require a longer execution time than others. This function can be used to extend the timeout for the current callback invocation. The timeout is given in seconds from the point in time when the function is called.

Keyword arguments:

• dbx -- a db context of DbCtxRef
• timeout_secs -- timeout value

db_seterr

db_seterr(dbx, errstr) -> None

This function is used by the application to set an error string.

Keyword arguments:

• dbx -- a db context
• errstr -- an error message string

db_seterr_extended

db_seterr_extended(dbx, code, apptag_ns, apptag_tag, errstr) -> None

This function can be used to provide more structured error information from a db callback.

Keyword arguments:

• dbx -- a db context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• errstr -- an error message string

db_seterr_extended_info

db_seterr_extended_info(dbx, code, apptag_ns, apptag_tag,
                        error_info, errstr) -> None

This function can be used to provide structured error information in the same way as db_seterr_extended(), and additionally provide contents for the NETCONF element.

Keyword arguments:

• dbx -- a db context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• error_info -- a list of _lib.TagValue instances
• errstr -- an error message string

delayed_reply_error

delayed_reply_error(tctx, errstr) -> None

This function must be used to return an error when tha actual callback returned CONFD_DELAYED_RESPONSE.

Keyword arguments:

• tctx -- a transaction context
• errstr -- an error message string

delayed_reply_ok

delayed_reply_ok(tctx) -> None

This function must be used to return the equivalent of CONFD_OK when the actual callback returned CONFD_DELAYED_RESPONSE.

Keyword arguments:

• tctx -- a transaction context

delayed_reply_validation_warn

delayed_reply_validation_warn(tctx) -> None

This function must be used to return the equivalent of CONFD_VALIDATION_WARN when the cb_validate() callback returned CONFD_DELAYED_RESPONSE.

Keyword arguments:

• tctx -- a transaction context

error_seterr

error_seterr(uinfo, errstr) -> None

This function must be called by format_error() (above) to provide a replacement for the default error message. If format_error() is called without calling error_seterr() the default message will be used.

Keyword arguments:

• uinfo -- a user info context
• errstr -- an string describing the error

fd_ready

fd_ready(dx, sock) -> None

The database application owns all data provider sockets to ConfD and is responsible for the polling of these sockets. When one of the ConfD sockets has I/O ready to read, the application must invoke fd_ready() on the socket.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• sock -- the socket

init_daemon

init_daemon(name) -> DaemonCtxRef

Initializes and returns a new daemon context.

Keyword arguments:

• name -- a string used to uniquely identify the daemon

install_crypto_keys

install_crypto_keys(dtx) -> None

It is possible to define AES keys inside confd.conf. These keys are used by ConfD to encrypt data which is entered into the system. The supported types are tailf:aes-cfb-128-encrypted-string and tailf:aes-256-cfb-128-encrypted-string. This function will copy those keys from ConfD (which reads confd.conf) into memory in the library.

This function must be called before register_done() is called.

Keyword arguments:

• dtx -- a daemon context wich is connected through a call to connect()

nano_service_reply_proplist

nano_service_reply_proplist(tctx, proplist) -> None

This function must be called with the new property list, immediately prior to returning from the callback, if the stored property list should be updated. If a callback returns without calling nano_service_reply_proplist(), the previous property list is retained. To completely delete the property list, call this function with the proplist argument set to an empty list or None.

The proplist argument should be a list of 2-tuples built up like this: list( (name, value), (name, value), ... ) In a 2-tuple both 'name' and 'value' must be strings.

Keyword arguments:

• tctx -- a transaction context
• proplist -- a list of properties or None

notification_flush

notification_flush(nctx) -> None

Notifications are sent asynchronously, i.e. normally without blocking the caller of the send functions described above. This means that in some cases ConfD's sending of the notifications on the northbound interfaces may lag behind the send calls. This function can be used to make sure that the notifications have actually been sent out.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()

notification_replay_complete

notification_replay_complete(nctx) -> None

The application calls this function to notify ConfD that the replay is complete

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()

notification_replay_failed

notification_replay_failed(nctx) -> None

In case the application fails to complete the replay as requested (e.g. the log gets overwritten while the replay is in progress), the application should call this function instead of notification_replay_complete(). An error message describing the reason for the failure can be supplied by first calling notification_seterr() or notification_seterr_extended().

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()

notification_reply_log_times

notification_reply_log_times(nctx, creation, aged) -> None

Reply function for use in the cb_get_log_times() callback invocation. If no notifications have been aged out of the log, give None for the aged argument.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• creation -- a _lib.DateTime instance
• aged -- a _lib.DateTime instance or None

notification_send

notification_send(nctx, time, values) -> None

This function is called by the application to send a notification defined at the top level of a YANG module, whether "live" or replay.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• time -- a _lib.DateTime instance
• values -- a list of _lib.TagValue instances or None

notification_send_path

notification_send_path(nctx, time, values, path) -> None

This function is called by the application to send a notification defined as a child of a container or list in a YANG 1.1 module, whether "live" or replay.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• time -- a _lib.DateTime instance
• values -- a list of _lib.TagValue instances or None
• path -- path to the parent of the notification in the data tree

notification_send_snmp

notification_send_snmp(nctx, notification, varbinds) -> None

Sends the SNMP notification specified by 'notification', without requesting inform-request delivery information. This is equivalent to calling notification_send_snmp_inform() with None as the cb_id argument. I.e. if the common arguments are the same, the two functions will send the exact same set of traps and inform-requests.

Keyword arguments:

• nctx -- notification context returned from register_snmp_notification()
• notification -- the notification string
• varbinds -- a list of _lib.SnmpVarbind instances or None

notification_send_snmp_inform

notification_send_snmp_inform(nctx, notification, varbinds, cb_id, ref) ->None

Sends the SNMP notification specified by notification. If cb_id is not None the callbacks registered for cb_id will be invoked with the ref argument.

Keyword arguments:

• nctx -- notification context returned from register_snmp_notification()
• notification -- the notification string
• varbinds -- a list of _lib.SnmpVarbind instances or None
• cb_id -- callback id
• ref -- argument send to callbacks

notification_set_fd

notification_set_fd(nctx, sock) -> None

This function may optionally be called by the cb_replay() callback to request that the worker socket given by 'sock' should be used for the replay. Otherwise the socket specified in register_notification_stream() will be used.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• sock -- a previously connected worker socket

notification_set_snmp_notify_name

notification_set_snmp_notify_name(nctx, notify_name) -> None

This function can be used to change the snmpNotifyName (notify_name) for the nctx context.

Keyword arguments:

• nctx -- notification context returned from register_snmp_notification()
• notify_name -- the snmpNotifyName

notification_set_snmp_src_addr

notification_set_snmp_src_addr(nctx, family, src_addr) -> None

By default, the source address for the SNMP notifications that are sent by the above functions is chosen by the IP stack of the OS. This function may be used to select a specific source address, given by src_addr, for the SNMP notifications subsequently sent using the nctx context. The default can be restored by calling the function with family set to AF_UNSPEC.

Keyword arguments:

• nctx -- notification context returned from register_snmp_notification()
• family -- AF_INET, AF_INET6 or AF_UNSPEC
• src_addr -- the source address in string format

notification_seterr

notification_seterr(nctx, errstr) -> None

In some cases the callbacks may be unable to carry out the requested actions, e.g. the capacity for simultaneous replays might be exceeded, and they can then return CONFD_ERR. This function allows the callback to associate an error message with the failure. It can also be used to supply an error message before calling notification_replay_failed().

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• errstr -- an error message string

notification_seterr_extended

notification_seterr_extended(nctx, code, apptag_ns, apptag_tag, errstr) ->None

This function can be used to provide more structured error information from a notification callback.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• errstr -- an error message string

notification_seterr_extended_info

notification_seterr_extended_info(nctx, code, apptag_ns, apptag_tag,
                                  error_info, errstr) -> None

This function can be used to provide structured error information in the same way as notification_seterr_extended(), and additionally provide contents for the NETCONF element.

Keyword arguments:

• nctx -- notification context returned from register_notification_stream()
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• error_info -- a list of _lib.TagValue instances
• errstr -- an error message string

register_action_cbs

register_action_cbs(dx, actionpoint, acb) -> None

This function registers up to five callback functions, two of which will be called in sequence when an action is invoked.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• actionpoint -- the name of the action point
• vcb -- the callback instance (see below)

The acb argument should be an instance of a class with callback methods. E.g.:

class ActionCallbacks(object):
    def cb_init(self, uinfo):
        pass

    def cb_abort(self, uinfo):
        pass

    def cb_action(self, uinfo, name, kp, params):
        pass

    def cb_command(self, uinfo, path, argv):
        pass

    def cb_completion(self, uinfo, cli_style, token, completion_char,
                      kp, cmdpath, cmdparam_id, simpleType, extra):
        pass

acb = ActionCallbacks()
dp.register_action_cbs(dx, 'actionpoint-1', acb)

Notes about some of the callbacks:

cb_action() The params argument is a list of _lib.TagValue instances.

cb_command() The argv argument is a list of strings.

register_auth_cb

register_auth_cb(dx, acb) -> None

Registers the authentication callback.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• abc -- the callback instance (see below)

E.g.:

class AuthCallbacks(object):
    def cb_auth(self, actx):
        pass

acb = AuthCallbacks()
dp.register_auth_cb(dx, acb)

register_authorization_cb

register_authorization_cb(dx, acb, cmd_filter, data_filter) -> None

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• abc -- the callback instance (see below)
• cmd_filter -- set to 0 for no filtering
• data_filter -- set to 0 for no filtering

E.g.:

class AuthorizationCallbacks(object):
    def cb_chk_cmd_access(self, actx, cmdtokens, cmdop):
        pass

    def cb_chk_data_access(self, actx, hashed_ns, hkp, dataop, how):
        pass

acb = AuthCallbacks()
dp.register_authorization_cb(dx, acb)

register_data_cb

register_data_cb(dx, callpoint, data, flags) -> None

Registers data manipulation callback functions.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• callpoint -- name of a tailf:callpoint in the data model
• data -- the callback instance (see below)
• flags -- data callbacks flags, dp.DATA_* (optional)

The data argument should be an instance of a class with callback methods. E.g.:

class DataCallbacks(object):
    def cb_exists_optional(self, tctx, kp):
        pass

    def cb_get_elem(self, tctx, kp):
        pass

    def cb_get_next(self, tctx, kp, next):
        pass

    def cb_set_elem(self, tctx, kp, newval):
        pass

    def cb_create(self, tctx, kp):
        pass

    def cb_remove(self, tctx, kp):
        pass

    def cb_find_next(self, tctx, kp, type, keys):
        pass

    def cb_num_instances(self, tctx, kp):
        pass

    def cb_get_object(self, tctx, kp):
        pass

    def cb_get_next_object(self, tctx, kp, next):
        pass

    def cb_find_next_object(self, tctx, kp, type, keys):
        pass

    def cb_get_case(self, tctx, kp, choice):
        pass

    def cb_set_case(self, tctx, kp, choice, caseval):
        pass

    def cb_get_attrs(self, tctx, kp, attrs):
        pass

    def cb_set_attr(self, tctx, kp, attr, v):
        pass

    def cb_move_after(self, tctx, kp, prevkeys):
        pass

    def cb_write_all(self, tctx, kp):
        pass

dcb = DataCallbacks()
dp.register_data_cb(dx, 'example-callpoint-1', dcb)

register_db_cb

register_db_cb(dx, dbcbs) -> None

This function is used to set callback functions which span over several ConfD transactions.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• dbcbs -- the callback instance (see below)

The dbcbs argument should be an instance of a class with callback methods. E.g.:

class DbCallbacks(object):
    def cb_candidate_commit(self, dbx, timeout):
        pass

    def cb_candidate_confirming_commit(self, dbx):
        pass

    def cb_candidate_reset(self, dbx):
        pass

    def cb_candidate_chk_not_modified(self, dbx):
        pass

    def cb_candidate_rollback_running(self, dbx):
        pass

    def cb_candidate_validate(self, dbx):
        pass

    def cb_add_checkpoint_running(self, dbx):
        pass

    def cb_del_checkpoint_running(self, dbx):
        pass

    def cb_activate_checkpoint_running(self, dbx):
        pass

    def cb_copy_running_to_startup(self, dbx):
        pass

    def cb_running_chk_not_modified(self, dbx):
        pass

    def cb_lock(self, dbx, dbname):
        pass

    def cb_unlock(self, dbx, dbname):
        pass

    def cb_lock_partial(self, dbx, dbname, lockid, paths):
        pass

    def cb_ulock_partial(self, dbx, dbname, lockid):
        pass

    def cb_delete_confid(self, dbx, dbname):
        pass

dbcbs = DbCallbacks()
dp.register_db_cb(dx, dbcbs)

register_done

register_done(dx) -> None

When we have registered all the callbacks for a daemon (including the other types described below if we have them), we must call this function to synchronize with ConfD. No callbacks will be invoked until it has been called, and after the call, no further registrations are allowed.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()

register_error_cb

register_error_cb(dx, errortypes, ecbs) -> None

This funciton can be used to register error callbacks that are invoked for internally generated errors.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• errortypes -- logical OR of the error types that the ecbs should handle
• ecbs -- the callback instance (see below)

E.g.:

class ErrorCallbacks(object):
    def cb_format_error(self, uinfo, errinfo_dict, default_msg):
        dp.error_seterr(uinfo, default_msg)
ecbs = ErrorCallbacks()
dp.register_error_cb(ctx,
                     dp.ERRTYPE_BAD_VALUE |
                     dp.ERRTYPE_MISC, ecbs)
dp.register_done(ctx)

register_nano_service_cb

register_nano_service_cb(dx,servicepoint,componenttype,state,nscb) -> None

This function registers the nano service callbacks.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• servicepoint -- name of the service point (string)
• componenttype -- name of the plan component for the nano service (string)
• state -- name of component state for the nano service (string)
• nscb -- the nano callback instance (see below)

E.g:

class NanoServiceCallbacks(object):
    def cb_nano_create(self, tctx, root, service, plan,
                       component, state, proplist, compproplist):
        pass

    def cb_nano_delete(self, tctx, root, service, plan,
                       component, state, proplist, compproplist):
        pass

nscb = NanoServiceCallbacks()
dp.register_nano_service_cb(dx, 'service-point-1', 'comp', 'state', nscb)

register_notification_snmp_inform_cb

register_notification_snmp_inform_cb(dx, cb_id, cbs) -> None

If we want to receive information about the delivery of SNMP inform-requests, we must register two callbacks for this.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• cb_id -- the callback identifier
• cbs -- the callback instance (see below)

E.g.:

class NotifySnmpCallbacks(object):
    def cb_targets(self, nctx, ref, targets):
        pass

    def cb_result(self, nctx, ref, target, got_response):
        pass

cbs = NotifySnmpCallbacks()
dp.register_notification_snmp_inform_cb(dx, 'callback-id-1', cbs)

register_notification_stream

register_notification_stream(dx, ncbs, sock, streamname) -> NotificationCtxRef

This function registers the notification stream and optionally two callback functions used for the replay functionality.

The returned notification context must be used by the application for the sending of live notifications via notification_send() or notification_send_path().

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• ncbs -- the callback instance (see below)
• sock -- a previously connected worker socket
• streamname -- the name of the notification stream

E.g.:

class NotificationCallbacks(object):
    def cb_get_log_times(self, nctx):
        pass

    def cb_replay(self, nctx, start, stop):
        pass

ncbs = NotificationCallbacks()
livectx = dp.register_notification_stream(dx, ncbs, workersock,
'streamname')

register_notification_sub_snmp_cb

register_notification_sub_snmp_cb(dx, sub_id, cbs) -> None

Registers a callback function to be called when an SNMP notification is received by the SNMP gateway.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• sub_id -- the subscription id for the notifications
• cbs -- the callback instance (see below)

E.g.:

class NotifySubSnmpCallbacks(object):
    def cb_recv(self, nctx, notification, varbinds, src_addr, port):
        pass

cbs = NotifySubSnmpCallbacks()
dp.register_notification_sub_snmp_cb(dx, 'sub-id-1', cbs)

register_range_action_cbs

register_range_action_cbs(dx, actionpoint, acb, lower, upper, path) -> None

A variant of register_action_cbs() which registers action callbacks for a range of key values. The lower, upper, and path arguments are the same as for register_range_data_cb().

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• actionpoint -- the name of the action point
• data -- the callback instance (see register_action_cbs())
• lower -- a list of Value's or None
• upper -- a list of Value's or None
• path -- path for the list (string)

register_range_data_cb

register_range_data_cb(dx, callpoint, data, lower, upper, path,
                       flags) -> None

This is a variant of register_data_cb() which registers a set of callbacks for a range of list entries.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• callpoint -- name of a tailf:callpoint in the data model
• data -- the callback instance (see register_data_cb())
• lower -- a list of Value's or None
• upper -- a list of Value's or None
• path -- path for the list (string)
• flags -- data callbacks flags, dp.DATA_* (optional)

register_range_valpoint_cb

register_range_valpoint_cb(dx, valpoint, vcb, lower, upper, path) -> None

A variant of register_valpoint_cb() which registers a validation function for a range of key values. The lower, upper and path arguments are the same as for register_range_data_cb().

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• valpoint -- name of a validation point
• data -- the callback instance (see register_valpoint_cb())
• lower -- a list of Value's or None
• upper -- a list of Value's or None
• path -- path for the list (string)

register_service_cb

register_service_cb(dx, servicepoint, scb) -> None

This function registers the service callbacks.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• servicepoint -- name of the service point (string)
• scb -- the callback instance (see below)

E.g:

class ServiceCallbacks(object):
    def cb_create(self, tctx, kp, proplist, fastmap_thandle):
        pass

    def cb_pre_modification(self, tctx, op, kp, proplist):
        pass

    def cb_post_modification(self, tctx, op, kp, proplist):
        pass

scb = ServiceCallbacks()
dp.register_service_cb(dx, 'service-point-1', scb)

register_snmp_notification

register_snmp_notification(dx, sock, notify_name, ctx_name) -> NotificationCtxRef

SNMP notifications can also be sent via the notification framework, however most aspects of the stream concept do not apply for SNMP. This function is used to register a worker socket, the snmpNotifyName (notify_name), and SNMP context (ctx_name) to be used for the notifications.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• sock -- a previously connected worker socket
• notify_name -- the snmpNotifyName
• ctx_name -- the SNMP context

register_trans_cb

register_trans_cb(dx, trans) -> None

Registers transaction callback functions.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• trans -- the callback instance (see below)

The trans argument should be an instance of a class with callback methods. E.g.:

class TransCallbacks(object):
    def cb_init(self, tctx):
        pass

    def cb_trans_lock(self, tctx):
        pass

    def cb_trans_unlock(self, tctx):
        pass

    def cb_write_start(self, tctx):
        pass

    def cb_prepare(self, tctx):
        pass

    def cb_abort(self, tctx):
        pass

    def cb_commit(self, tctx):
        pass

    def cb_finish(self, tctx):
        pass

    def cb_interrupt(self, tctx):
        pass

tcb = TransCallbacks()
dp.register_trans_cb(dx, tcb)

register_trans_validate_cb

register_trans_validate_cb(dx, vcbs) -> None

This function installs two callback functions for the daemon context. One function that gets called when the validation phase starts in a transaction and one when the validation phase stops in a transaction.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• vcbs -- the callback instance (see below)

The vcbs argument should be an instance of a class with callback methods. E.g.:

class TransValidateCallbacks(object):
    def cb_init(self, tctx):
        pass

    def cb_stop(self, tctx):
        pass

vcbs = TransValidateCallbacks()
dp.register_trans_validate_cb(dx, vcbs)

register_usess_cb

register_usess_cb(dx, ucb) -> None

This function can be used to register information callbacks that are invoked for user session start and stop.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• ucb -- the callback instance (see below)

E.g.:

class UserSessionCallbacks(object):
    def cb_start(self, dx, uinfo):
        pass

    def cb_stop(self, dx, uinfo):
        pass

ucb = UserSessionCallbacks()
dp.register_usess_cb(dx, acb)

register_valpoint_cb

register_valpoint_cb(dx, valpoint, vcb) -> None

We must also install an actual validation function for each validation point, i.e. for each tailf:validate statement in the YANG data model.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• valpoint -- the name of the validation point
• vcb -- the callback instance (see below)

The vcb argument should be an instance of a class with a callback method. E.g.:

class ValpointCallback(object):
    def cb_validate(self, tctx, kp, newval):
        pass

vcb = ValpointCallback()
dp.register_valpoint_cb(dx, 'valpoint-1', vcb)

release_daemon

release_daemon(dx) -> None

Releases all memory that has been allocated by init_daemon() and other functions for the daemon context. The control socket as well as all the worker sockets must be closed by the application (before or after release_daemon() has been called).

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()

service_reply_proplist

service_reply_proplist(tctx, proplist) -> None

This function must be called with the new property list, immediately prior to returning from the callback, if the stored property list should be updated. If a callback returns without calling service_reply_proplist(), the previous property list is retained. To completely delete the property list, call this function with the proplist argument set to an empty list or None.

The proplist argument should be a list of 2-tuples built up like this: list( (name, value), (name, value), ... ) In a 2-tuple both 'name' and 'value' must be strings.

Keyword arguments:

• tctx -- a transaction context
• proplist -- a list of properties or None

set_daemon_flags

set_daemon_flags(dx, flags) -> None

Modifies the API behaviour according to the flags ORed into the flags argument.

Keyword arguments:

• dx -- a daemon context acquired through a call to init_daemon()
• flags -- the flags to set

trans_set_fd

trans_set_fd(tctx, sock) -> None

Associate a worker socket with the transaction, or validation phase. This function must be called in the transaction and validation cb_init() callbacks.

Keyword arguments:

• tctx -- a transaction context
• sock -- a previously connected worker socket

A minimal implementation of a transaction cb_init() callback looks like:

class TransCb(object):
    def __init__(self, workersock):
        self.workersock = workersock

    def cb_init(self, tctx):
        dp.trans_set_fd(tctx, self.workersock)

trans_seterr

trans_seterr(tctx, errstr) -> None

This function is used by the application to set an error string.

Keyword arguments:

• tctx -- a transaction context
• errstr -- an error message string

trans_seterr_extended

trans_seterr_extended(tctx, code, apptag_ns, apptag_tag, errstr) -> None

This function can be used to provide more structured error information from a transaction or data callback.

Keyword arguments:

• tctx -- a transaction context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• errstr -- an error message string

trans_seterr_extended_info

trans_seterr_extended_info(tctx, code, apptag_ns, apptag_tag,
                           error_info, errstr) -> None

This function can be used to provide structured error information in the same way as trans_seterr_extended(), and additionally provide contents for the NETCONF element.

Keyword arguments:

• tctx -- a transaction context
• code -- an error code
• apptag_ns -- namespace - should be set to 0
• apptag_tag -- either 0 or the hash value for a data model node
• error_info -- a list of _lib.TagValue instances
• errstr -- an error message string

Classes

class AuthCtxRef

This type represents the c-type struct confd_auth_ctx.

Available attributes:

• uinfo -- the user info (UserInfo)
• method -- the method (string)
• success -- success or failure (bool)
• groups -- authorization groups if success is True (list of strings)
• logno -- log number if success is False (int)
• reason -- error reason if success is False (string)

AuthCtxRef cannot be directly instantiated from Python.

Members:

None

class AuthorizationCtxRef

This type represents the c-type struct confd_authorization_ctx.

Available attributes:

• uinfo -- the user info (UserInfo) or None
• groups -- authorization groups (list of strings) or None

AuthorizationCtxRef cannot be directly instantiated from Python.

Members:

None

class DaemonCtxRef

struct confd_daemon_ctx references object

Members:

None

class DbCtxRef

This type represents the c-type struct confd_db_ctx.

DbCtxRef cannot be directly instantiated from Python.

Members:

did(...)

Method:

did() -> int

dx(...)

Method:

dx() -> DaemonCtxRef

lastop(...)

Method:

lastop() -> int

qref(...)

Method:

qref() -> int

uinfo(...)

Method:

uinfo() -> _ncs.UserInfo

class ListFilter

This type represents the c-type struct confd_list_filter.

Available attributes:

• type -- filter type, LF_*
• expr1 -- OR, AND, NOT expression
• expr2 -- OR, AND expression
• op -- operation, CMP_* and EXEC_*
• node -- filter tagpath
• val -- filter value

ListFilter cannot be directly instantiated from Python.

Members:

None

class NotificationCtxRef

This type represents the c-type struct confd_notification_ctx.

Available attributes:

• name -- stream name or snmp notify name (string or None)
• ctx_name -- for snmp only (string or None)
• fd -- worker socket (int)
• dx -- the daemon context (DaemonCtxRef)

NotificationCtxRef cannot be directly instantiated from Python.

Members:

None

class TrItemRef

This type represents the c-type confd_tr_item.

Available attributes:

• callpoint -- the callpoint (string)
• op -- operation, one of C_SET_ELEM, C_CREATE, C_REMOVE, C_SET_CASE, C_SET_ATTR or C_MOVE_AFTER (int)
• hkp -- the keypath (HKeypathRef)
• val -- the value (Value or None)
• choice -- the choice, only for C_SET_CASE (Value or None)
• attr -- attribute, only for C_SET_ATTR (int or None)
• next -- the next TrItemRef object in the linked list or None if no more items are found

TrItemRef cannot be directly instantiated from Python.

Members:

None

Predefined Values

ACCESS_CHK_DESCENDANT = 1024
ACCESS_CHK_FINAL = 512
ACCESS_CHK_INTERMEDIATE = 256
ACCESS_OP_CREATE = 4
ACCESS_OP_DELETE = 16
ACCESS_OP_EXECUTE = 2
ACCESS_OP_READ = 1
ACCESS_OP_UPDATE = 8
ACCESS_OP_WRITE = 32
ACCESS_RESULT_ACCEPT = 0
ACCESS_RESULT_CONTINUE = 2
ACCESS_RESULT_DEFAULT = 3
ACCESS_RESULT_REJECT = 1
BAD_VALUE_BAD_KEY_TAG = 32
BAD_VALUE_BAD_LEXICAL = 19
BAD_VALUE_BAD_TAG = 21
BAD_VALUE_BAD_VALUE = 20
BAD_VALUE_CUSTOM_FACET_ERROR_MESSAGE = 16
BAD_VALUE_ENUMERATION = 11
BAD_VALUE_FRACTION_DIGITS = 3
BAD_VALUE_INVALID_FACET = 18
BAD_VALUE_INVALID_REGEX = 9
BAD_VALUE_INVALID_TYPE_NAME = 23
BAD_VALUE_INVALID_UTF8 = 38
BAD_VALUE_INVALID_XPATH = 34
BAD_VALUE_INVALID_XPATH_AT_TAG = 40
BAD_VALUE_INVALID_XPATH_PATH = 39
BAD_VALUE_LENGTH = 15
BAD_VALUE_MAX_EXCLUSIVE = 5
BAD_VALUE_MAX_INCLUSIVE = 6
BAD_VALUE_MAX_LENGTH = 14
BAD_VALUE_MIN_EXCLUSIVE = 7
BAD_VALUE_MIN_INCLUSIVE = 8
BAD_VALUE_MIN_LENGTH = 13
BAD_VALUE_MISSING_KEY = 37
BAD_VALUE_MISSING_NAMESPACE = 27
BAD_VALUE_NOT_RESTRICTED_XPATH = 35
BAD_VALUE_NO_DEFAULT_NAMESPACE = 24
BAD_VALUE_PATTERN = 12
BAD_VALUE_POP_TOO_FAR = 31
BAD_VALUE_RANGE = 29
BAD_VALUE_STRING_FUN = 1
BAD_VALUE_SYMLINK_BAD_KEY_REFERENCE = 33
BAD_VALUE_TOTAL_DIGITS = 4
BAD_VALUE_UNIQUELIST = 10
BAD_VALUE_UNKNOWN_BIT_LABEL = 22
BAD_VALUE_UNKNOWN_NAMESPACE = 26
BAD_VALUE_UNKNOWN_NAMESPACE_PREFIX = 25
BAD_VALUE_USER_ERROR = 17
BAD_VALUE_VALUE2VALUE_FUN = 28
BAD_VALUE_WRONG_DECIMAL64_FRACTION_DIGITS = 2
BAD_VALUE_WRONG_NUMBER_IDENTIFIERS = 30
BAD_VALUE_XPATH_ERROR = 36
CLI_ACTION_NOT_FOUND = 13
CLI_AMBIGUOUS_COMMAND = 63
CLI_BAD_ACTION_RESPONSE = 16
CLI_BAD_LEAF_VALUE = 6
CLI_CDM_NOT_SUPPORTED = 74
CLI_COMMAND_ABORTED = 2
CLI_COMMAND_ERROR = 1
CLI_COMMAND_FAILED = 3
CLI_CONFIRMED_NOT_SUPPORTED = 39
CLI_COPY_CONFIG_FAILED = 32
CLI_COPY_FAILED = 31
CLI_COPY_PATH_IDENTICAL = 33
CLI_CREATE_PATH = 23
CLI_CUSTOM_ERROR = 4
CLI_DELETE_ALL_FAILED = 10
CLI_DELETE_ERROR = 12
CLI_DELETE_FAILED = 11
CLI_ELEMENT_DOES_NOT_EXIST = 66
CLI_ELEMENT_MANDATORY = 75
CLI_ELEMENT_NOT_FOUND = 14
CLI_ELEM_NOT_WRITABLE = 7
CLI_EXPECTED_BOL = 56
CLI_EXPECTED_EOL = 57
CLI_FAILED_COPY_RUNNING = 38
CLI_FAILED_CREATE_CONTEXT = 37
CLI_FAILED_OPEN_STARTUP = 41
CLI_FAILED_OPEN_STARTUP_CONFIG = 42
CLI_FAILED_TERM_REDIRECT = 49
CLI_ILLEGAL_DIRECTORY_NAME = 52
CLI_ILLEGAL_FILENAME = 53
CLI_INCOMPLETE_CMD_PATH = 67
CLI_INCOMPLETE_COMMAND = 9
CLI_INCOMPLETE_PATH = 8
CLI_INCOMPLETE_PATTERN = 64
CLI_INVALID_PARAMETER = 54
CLI_INVALID_PASSWORD = 21
CLI_INVALID_PATH = 58
CLI_INVALID_ROLLBACK_NR = 15
CLI_INVALID_SELECT = 59
CLI_MESSAGE_TOO_LARGE = 48
CLI_MISSING_ACTION_PARAM = 17
CLI_MISSING_ACTION_PARAM_VALUE = 18
CLI_MISSING_ARGUMENT = 69
CLI_MISSING_DISPLAY_GROUP = 55
CLI_MISSING_ELEMENT = 65
CLI_MISSING_VALUE = 68
CLI_MOVE_FAILED = 30
CLI_MUST_BE_AN_INTEGER = 70
CLI_MUST_BE_INTEGER = 43
CLI_MUST_BE_TRUE_OR_FALSE = 71
CLI_NOT_ALLOWED = 5
CLI_NOT_A_DIRECTORY = 50
CLI_NOT_A_FILE = 51
CLI_NOT_FOUND = 28
CLI_NOT_SUPPORTED = 34
CLI_NOT_WRITABLE = 27
CLI_NO_SUCH_ELEMENT = 45
CLI_NO_SUCH_SESSION = 44
CLI_NO_SUCH_USER = 47
CLI_ON_LINE = 25
CLI_ON_LINE_DESC = 26
CLI_OPEN_FILE = 20
CLI_READ_ERROR = 19
CLI_REALLOCATE = 24
CLI_SENSITIVE_DATA = 73
CLI_SET_FAILED = 29
CLI_START_REPLAY_FAILED = 72
CLI_TARGET_EXISTS = 35
CLI_UNKNOWN_ARGUMENT = 61
CLI_UNKNOWN_COMMAND = 62
CLI_UNKNOWN_ELEMENT = 60
CLI_UNKNOWN_HIDEGROUP = 22
CLI_UNKNOWN_MODE = 36
CLI_WILDCARD_NOT_ALLOWED = 46
CLI_WRITE_CONFIG_FAILED = 40
COMPLETION = 0
COMPLETION_DEFAULT = 3
COMPLETION_DESC = 2
COMPLETION_INFO = 1
CONTROL_SOCKET = 0
C_CREATE = 2
C_MOVE_AFTER = 6
C_REMOVE = 3
C_SET_ATTR = 5
C_SET_CASE = 4
C_SET_ELEM = 1
DAEMON_FLAG_BULK_GET_CONTAINER = 128
DAEMON_FLAG_NO_DEFAULTS = 4
DAEMON_FLAG_PREFER_BULK_GET = 64
DAEMON_FLAG_REG_DONE = 65536
DAEMON_FLAG_REG_REPLACE_DISCONNECT = 16
DAEMON_FLAG_SEND_IKP = 1
DAEMON_FLAG_STRINGSONLY = 2
DATA_AFTER = 1
DATA_BEFORE = 0
DATA_CREATE = 0
DATA_DELETE = 1
DATA_FIRST = 2
DATA_INSERT = 2
DATA_LAST = 3
DATA_MERGE = 3
DATA_MOVE = 4
DATA_REMOVE = 6
DATA_REPLACE = 5
DATA_WANT_FILTER = 1
ERRTYPE_BAD_VALUE = 2
ERRTYPE_CLI = 4
ERRTYPE_MISC = 8
ERRTYPE_NCS = 16
ERRTYPE_OPERATION = 32
ERRTYPE_VALIDATION = 1
MISC_ACCESS_DENIED = 5
MISC_APPLICATION = 19
MISC_APPLICATION_INTERNAL = 20
MISC_BAD_PERSIST_ID = 16
MISC_CANDIDATE_ABORT_BAD_USID = 17
MISC_CDB_OPER_UNAVAILABLE = 37
MISC_CONF_LOAD_NOT_ALLOWED = 59
MISC_DATA_MISSING = 44
MISC_EXTERNAL = 22
MISC_EXTERNAL_TIMEOUT = 45
MISC_FILE_ACCESS_PATH = 33
MISC_FILE_BAD_PATH = 34
MISC_FILE_BAD_VALUE = 35
MISC_FILE_CORRUPT = 52
MISC_FILE_CREATE_PATH = 29
MISC_FILE_DELETE_PATH = 32
MISC_FILE_EOF = 36
MISC_FILE_MOVE_PATH = 30
MISC_FILE_OPEN_ERROR = 27
MISC_FILE_SET_PATH = 31
MISC_FILE_SYNTAX_ERROR = 28
MISC_FILE_SYNTAX_ERROR_1 = 26
MISC_HA_ABORT = 55
MISC_INCONSISTENT_VALUE = 7
MISC_INDEXED_VIEW_LIST_HOLE = 46
MISC_INDEXED_VIEW_LIST_TOO_BIG = 18
MISC_INTERNAL = 21
MISC_INTERRUPT = 10
MISC_IN_USE = 3
MISC_LOCKED_BY = 4
MISC_MISSING_INSTANCE = 8
MISC_NODE_IS_READONLY = 13
MISC_NODE_WAS_READONLY = 14
MISC_NOT_IMPLEMENTED = 43
MISC_NO_SUCH_FILE = 2
MISC_OPERATION_NOT_SUPPORTED = 38
MISC_PROTO_USAGE = 23
MISC_REACHED_MAX_RETRIES = 56
MISC_RESOLVE_NEEDED = 53
MISC_RESOURCE_DENIED = 6
MISC_ROLLBACK_DISABLED = 1
MISC_ROTATE_LIST_KEY = 58
MISC_SNMP_BAD_INDEX = 42
MISC_SNMP_BAD_VALUE = 41
MISC_SNMP_ERROR = 39
MISC_SNMP_TIMEOUT = 40
MISC_SUBAGENT_DOWN = 24
MISC_SUBAGENT_ERROR = 25
MISC_TOO_MANY_SESSIONS = 11
MISC_TOO_MANY_TRANSACTIONS = 12
MISC_TRANSACTION_CONFLICT = 54
MISC_UNSUPPORTED_XML_ENCODING = 57
MISC_UPGRADE_IN_PROGRESS = 15
MISC_WHEN_FAILED = 9
MISC_XPATH_COMPILE = 51
NCS_BAD_AUTHGROUP_CALLBACK_RESPONSE = 104
NCS_BAD_CAPAS = 14
NCS_CALL_HOME = 107
NCS_CLI_LOAD = 19
NCS_COMMIT_QUEUED = 20
NCS_COMMIT_QUEUED_AND_DELETED = 113
NCS_COMMIT_QUEUE_DISABLED = 111
NCS_COMMIT_QUEUE_HAS_OVERLAPPING = 103
NCS_COMMIT_QUEUE_HAS_SENTINEL = 75
NCS_CONFIG_LOCKED = 84
NCS_CONFLICTING_INTENT = 125
NCS_CONNECTION_CLOSED = 10
NCS_CONNECTION_REFUSED = 5
NCS_CONNECTION_TIMEOUT = 8
NCS_CQ_BLOCK_OTHERS = 21
NCS_CQ_REMOTE_NOT_ENABLED = 22
NCS_DEV_AUTH_FAILED = 1
NCS_DEV_IN_USE = 81
NCS_HOST_LOOKUP = 12
NCS_INVALID_RECONCILE_EXCLUDE_PATH = 131
NCS_LOCKED = 3
NCS_NCS_ACTION_NO_TRANSACTION = 67
NCS_NCS_ALREADY_EXISTS = 82
NCS_NCS_CLUSTER_AUTH_FAILED = 74
NCS_NCS_DEV_ERROR = 69
NCS_NCS_ERROR = 68
NCS_NCS_ERROR_IKP = 70
NCS_NCS_LOAD_TEMPLATE_COPY_TREE_CROSS_NS = 96
NCS_NCS_LOAD_TEMPLATE_DUPLICATE_MACRO = 119
NCS_NCS_LOAD_TEMPLATE_EOF_XML = 33
NCS_NCS_LOAD_TEMPLATE_EXTRA_MACRO_VARS = 118
NCS_NCS_LOAD_TEMPLATE_INVALID_CBTYPE = 128
NCS_NCS_LOAD_TEMPLATE_INVALID_PI_REGEX = 122
NCS_NCS_LOAD_TEMPLATE_INVALID_PI_SYNTAX = 86
NCS_NCS_LOAD_TEMPLATE_INVALID_VALUE_XML = 30
NCS_NCS_LOAD_TEMPLATE_MISPLACED_IF_NED_ID_MATCH_XML = 121
NCS_NCS_LOAD_TEMPLATE_MISPLACED_IF_NED_ID_XML = 110
NCS_NCS_LOAD_TEMPLATE_MISSING_ELEMENT2_XML = 98
NCS_NCS_LOAD_TEMPLATE_MISSING_ELEMENT_XML = 29
NCS_NCS_LOAD_TEMPLATE_MISSING_MACRO_VARS = 117
NCS_NCS_LOAD_TEMPLATE_MULTIPLE_ELEMENTS_XML = 38
NCS_NCS_LOAD_TEMPLATE_MULTIPLE_KEY_LEAFS_XML = 77
NCS_NCS_LOAD_TEMPLATE_MULTIPLE_SP_XML = 35
NCS_NCS_LOAD_TEMPLATE_SHADOWED_NED_ID_XML = 109
NCS_NCS_LOAD_TEMPLATE_TAG_AMBIGUOUS_XML = 102
NCS_NCS_LOAD_TEMPLATE_TRAILING_XML = 32
NCS_NCS_LOAD_TEMPLATE_UNCLOSED_PI = 88
NCS_NCS_LOAD_TEMPLATE_UNEXPECTED_PI = 89
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_ATTRIBUTE_XML = 31
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_ELEMENT2_XML = 97
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_ELEMENT_XML = 36
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_MACRO = 116
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_NED_ID_XML = 99
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_NS_XML = 37
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_PI = 85
NCS_NCS_LOAD_TEMPLATE_UNKNOWN_SP_XML = 34
NCS_NCS_LOAD_TEMPLATE_UNMATCHED_PI = 87
NCS_NCS_LOAD_TEMPLATE_UNSUPPORTED_NED_ID_AT_TAG_XML = 101
NCS_NCS_LOAD_TEMPLATE_UNSUPPORTED_NED_ID_XML = 100
NCS_NCS_LOAD_TEMPLATE_UNSUPPORTED_NETCONF_YANG_ATTRIBUTES = 126
NCS_NCS_LOAD_TEMPLATE_UNSUPPORTED_PI = 133
NCS_NCS_MISSING_CLUSTER_AUTH = 73
NCS_NCS_MISSING_VARIABLES = 52
NCS_NCS_NED_MULTI_ERROR = 76
NCS_NCS_NO_CAPABILITIES = 64
NCS_NCS_NO_DIFF = 71
NCS_NCS_NO_FORWARD_DIFF = 72
NCS_NCS_NO_NAMESPACE = 65
NCS_NCS_NO_SP_TEMPLATE = 48
NCS_NCS_NO_TEMPLATE = 47
NCS_NCS_NO_TEMPLATE_XML = 23
NCS_NCS_NO_WRITE_TRANSACTION = 66
NCS_NCS_OPERATION_LOCKED = 83
NCS_NCS_PACKAGE_SYNC_MISMATCHED_LOAD_PATH = 123
NCS_NCS_SERVICE_CONFLICT = 78
NCS_NCS_TEMPLATE_CONTEXT_NODE_NOEXISTS = 90
NCS_NCS_TEMPLATE_COPY_TREE_BAD_OP = 94
NCS_NCS_TEMPLATE_FOREACH = 51
NCS_NCS_TEMPLATE_FOREACH_XML = 28
NCS_NCS_TEMPLATE_GUARD_LENGTH = 59
NCS_NCS_TEMPLATE_GUARD_LENGTH_XML = 44
NCS_NCS_TEMPLATE_INSERT = 55
NCS_NCS_TEMPLATE_INSERT_XML = 40
NCS_NCS_TEMPLATE_LONE_GUARD = 57
NCS_NCS_TEMPLATE_LONE_GUARD_XML = 42
NCS_NCS_TEMPLATE_LOOP_PREVENTION = 95
NCS_NCS_TEMPLATE_MISSING_VALUE = 56
NCS_NCS_TEMPLATE_MISSING_VALUE_XML = 41
NCS_NCS_TEMPLATE_MOVE = 60
NCS_NCS_TEMPLATE_MOVE_XML = 45
NCS_NCS_TEMPLATE_MULTIPLE_CONTEXT_NODES = 92
NCS_NCS_TEMPLATE_NOT_CREATED = 80
NCS_NCS_TEMPLATE_NOT_CREATED_XML = 79
NCS_NCS_TEMPLATE_ORDERED_LIST = 54
NCS_NCS_TEMPLATE_ORDERED_LIST_XML = 39
NCS_NCS_TEMPLATE_ROOT_LEAF_LIST = 93
NCS_NCS_TEMPLATE_SAVED_CONTEXT_NOEXISTS = 91
NCS_NCS_TEMPLATE_STR2VAL = 61
NCS_NCS_TEMPLATE_STR2VAL_XML = 46
NCS_NCS_TEMPLATE_UNSUPPORTED_NED_ID = 112
NCS_NCS_TEMPLATE_VALUE_LENGTH = 58
NCS_NCS_TEMPLATE_VALUE_LENGTH_XML = 43
NCS_NCS_TEMPLATE_WHEN = 50
NCS_NCS_TEMPLATE_WHEN_KEY_XML = 27
NCS_NCS_TEMPLATE_WHEN_XML = 26
NCS_NCS_XPATH = 53
NCS_NCS_XPATH_COMPILE = 49
NCS_NCS_XPATH_COMPILE_XML = 24
NCS_NCS_XPATH_VARBIND = 63
NCS_NCS_XPATH_XML = 25
NCS_NED_EXTERNAL_ERROR = 6
NCS_NED_INTERNAL_ERROR = 7
NCS_NED_OFFLINE_UNAVAILABLE = 108
NCS_NED_OUT_OF_SYNC = 18
NCS_NONED = 15
NCS_NO_EXISTS = 2
NCS_NO_TEMPLATE = 62
NCS_NO_YANG_MODULES = 16
NCS_NS_SUPPORT = 13
NCS_OVERLAPPING_PRESENCE_AND_ABSENCE_ASSERTION_COMPLIANCE_TEMPLATE = 127
NCS_OVERLAPPING_STRICT_ASSERTION_COMPLIANCE_TEMPLATE = 129
NCS_PARTIAL_RECONCILE_NOT_SUPPORTED = 130
NCS_PLAN_LOCATION = 120
NCS_REBASE_SCHEMA_ERROR = 132
NCS_REVDROP = 17
NCS_RPC_ERROR = 9
NCS_SERVICE_CREATE = 0
NCS_SERVICE_DELETE = 2
NCS_SERVICE_UPDATE = 1
NCS_SESSION_LIMIT_EXCEEDED = 115
NCS_SOUTHBOUND_LOCKED = 4
NCS_UNKNOWN_NED_ID = 105
NCS_UNKNOWN_NED_IDS_COMPLIANCE_TEMPLATE = 124
NCS_UNKNOWN_NED_ID_DEVICE_TEMPLATE = 106
NCS_XML_PARSE = 11
NCS_YANGLIB_NO_SCHEMA_FOR_RUNNING = 114
PATCH_FLAG_AAA_CHECKED = 8
PATCH_FLAG_BUFFER_DAMPENED = 2
PATCH_FLAG_FILTER = 4
PATCH_FLAG_INCOMPLETE = 1
WORKER_SOCKET = 1