Patent Description:
It is often the case that a user of a network management service needs to deploy a customized data model to a hosted service. Successfully deploying a data model typically requires binding functionality directly to a target device. As a result, operationalizing custom data models for a hosted service is often performed via a manual process of collaboration between the user and technicians or other specialists for the hosted service.

<CIT> discloses mechanisms for service layer interworking and resource extensibility. One disclosed example comprises defining a new service layer resource definition registration procedure that allows for specifying custom attributes of service layer resources to represent third party technology resources. A system for dynamic update of device data models is described in <CIT>.

Particular embodiments are defined by the subject-matter of the dependent claims. Embodiments which do not fall within the scope of the claims are to be interpreted merely as background information useful for understanding the invention.

Understanding that these drawings depict only exemplary embodiments of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompany drawings in which:.

Various embodiments of the disclosure are discussed in detail below. While specific representations are discussed, it should be understood that this is done for illustration purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used.

Thus, the following description and drawings are illustrative and are not to be construed as limiting. Numerous specific details are described to provide a thorough understanding of the disclosure. However, in certain cases, well-known or conventional details are not described in order to avoid obscuring the description. References to one or more embodiments in the present disclosure can be references to the same embodiment or any embodiment; and, such references mean at least one of the embodiments.

References to "one embodiment" or "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the disclosure.

The use of examples anywhere in this specification including examples of any terms discussed herein is illustrative only and is not intended to further limit the scope and meaning of the disclosure or of any example term.

Without intent to limit the scope of the disclosure, examples of instruments, apparatuses, methods, and their related results according to the embodiments of the present disclosure are given below. Note that titles or subtitles may be used in the examples for convenience of a read, which in no way should limit the scope of the disclosure.

These and other features of the disclosure can be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the disclosure will be become fully apparent from the following description and appended claims, or can be learned by the practice of the principles set forth herein.

Network device (e.g., routers, switches, etc.) capabilities can be extended dynamically by providing externally customized models to a model mapping process. In particular, data models (e.g., YANG, etc.) can be customized at a user device and provided to a network device (e.g., via a network management service, etc.). The customized data models may then be used to extend and/or augment existing data models stored on the network device to provide the functionality of the customized model. In addition, downstream devices and/or respective data models may be likewise extended to seamlessly deploy customized data models to network devices across a managed network.

In one example, a user provides definitions related to one or more changes in functionality of a data model for a network device. A mapping package including one or more mappings for the data model is generated based on the received definitions. A mapping translation engine deploys the mapping package to the network device and the network device operates according to the deployed mapping package (e.g., via controller configurations, etc.).

In some examples, a user can define elements of a data model based on particular user needs and the like. Generally, the data model may be formatted as a tree data structure, such as in YANG data models and the like. For example, various elements of the data model may be nested within, or be child elements of, other elements of the data model. As a result, the data model can be interpreted (by a computer, compiler, interpreter, etc.) as a tree structure with parent nodes and child nodes (which may themselves be parent nodes to additional child nodes), etc..

The user defined data model may then be provided to a translation and mapping process hosted on either a target network device or as an interim or middle-layer service between the user client and the target network device. The customized data model may be mapped to one or more network device models. In effect, relationships between network device data models and the customized data model may be identified in relation to particular features to generate a mapping.

In some examples, information related to the mapping, sometimes referred to as mapping knowledge, can be expressed as annotations (e.g., YANG, etc.). The annotations may serve as a mapping contract which informs interacting data types, formats, and functions of what to expect between each other. In particular, the mapping contract may inform an interpreter at runtime how to parse and process received data. In some examples, the mapping contract is received by code generators for configuring and loading dynamically linked libraries ("DLLs") to a network device identified by, for example, a device model registry.

As a result, user defined data models may extend stored models already accessible by the network device. Additionally, entirely new data models may be deployed to the network device as an overlay atop existing data models. A workflow for deploying customized data models to a network device may be as follows.

A user defines a customized data model as an overlay data model over a native (to the network device) or standard data model. In addition, the user may instead define the customized data model as an extension to a supported native or standard data model.

The customized data model is checked against the network device for feature support. In particular, hardware functionality and relevant local data model support are checked against the customized data model to ensure successful deployment. In some examples, where hardware functionality is not sufficient for deployment of the customized data model, the user may be prompted to remedy the issue. Likewise, if a mismatch is detected between the customized data model and a local data model, the user may be prompted to remedy the mismatch by updating the local model reference (e.g., mismatches of data model versions, types, etc.).

If the customized data model is compatible with the network device hardware and/or local data models, a mapping contract can be generated. The mapping contract may be automatically generated or may use user provided mapping definitions. In some examples, the generated mapping contract may be shared to a community repository or ecosystem for sharing feedback, optimizations, and/or implementation information.

The mapping contract can then be processed by a package generator to generate a mapping package. The mapping package may be of various file types and formats, such as ". mpkg" and the like. The package generator includes various pluggable mapping functions in various programming languages, such as C or Python, and may determine appropriate pluggable mapping functions based on, for example and without imputing limitation, included libraries in respective data models and the like.

The mapping package (e.g., a. mpkg file) may then be deployed to the network device. In some examples, a native operating system (OS) may host the deployed mapping package. In some examples, such as in "off-box" hosting, a separate device operating as a controller hosts the deployed mapping package. Further, in some examples, a guest OS and/or hosted process hosts the deployed mapping package to provide dynamic extension of the data model. Once hosted, the deployed mapping package (and by extension customized data models) can, for example, perform routing and network traffic management for a configured device such as a switch, router, etc..

<FIG> depicts a method <NUM> for deploying a data model to a network device. In particular, the network device such as a switch or the like may receive a data model, for example and without imputing limitation, to manage network traffic within a network.

At step <NUM>, data model definitions are received for a custom overlay. The custom overlay may be a customized data model that can overlay on a locally stored data model of the network device. For example, the network device may support a selection of native or open standard data models and a data model overlay may be used to enhance one or more of the native or open standard data models. Enhancements may include custom traffic management, security rules, business logic rules, and the like.

At step <NUM>, feature coverage for the network device of the local model(s) referenced by the received overlay are verified. For example, hardware specifications, protocols, etc. referenced by an overlay may be verified as matching the network device feature set to avoid returning errors at deployment of the data model to the network device. In some examples, where feature verification fails, a user may be prompted to update the model definitions to correct the failure.

At step <NUM>, a mapping contract is generated based on the received definitions. In some examples, the mapping contract is an annotated or marked up data structure such as an annotated YANG document or the like. The generated mapping contract identifies data sources, destinations, and treatment and may be associated with a single namespace. As a result, related data models (e.g., inheriting or otherwise incorporating the same namespace) may incorporate some or all of the data model overlay.

At step <NUM>, a mapping package is generated from the mapping contract. The mapping package may be a machine executable version of the mapping contract. For example, the mapping package may include referenced libraries, in whole or in part, linkages, and be formatted in a non-human readable structure. The mapping package can be compiled and/or interpreted by an appropriately configured program or process.

At step <NUM>, the mapping package is deployed to a native operating system, an off-box host, or a guest operating system and process host. In the case of a native operating system, the mapping package is deployed to the network device and the network device directly executes the data model of the mapping package. In the cases of an off-box host or guest operating system and process host, the mapping package may be deployed in whole or in part to an additional environment (either physical or virtual) associated with the network device. For example, the network device may host a guest operating system, such as a lightweight linux distribution, etc., for hosting a runtime translator to perform real-time mapping translations as needed or initiate side processes according to the custom data model overlay.

<FIG> depicts a method <NUM> for deploying an extension of a data model to a network device. Instead of, or in addition to, a data model overlay, existing data models may be extended to include additional features not otherwise available to a user, or available to an otherwise insufficient degree.

At step <NUM>, data model definitions for extending a locally stored data model are received. The locally stored data model can be a natively supported open data model or standard data model. Extending a data model may include, for example, adding new features, functions, data types, and the like to an existing data model. In some examples, the data model to be extended may be stored in a repository and associated with the user. As a result, a user may have a number of user-specific extended data models which can be accessed as needed.

At step <NUM>, versioning and presence of the locally stored data model are verified. For example, where data model definitions reference a particular native data model version, a respective data model repository (e.g., database, local memory, etc.) may be checked to ensure the referenced data model version is available either generally or to the user in particular.

Steps <NUM>-<NUM> may then proceed in substantially similar form to steps <NUM>-<NUM> discussed above. At step <NUM>, a mapping contract is generated based on the received definitions. At step <NUM>, a mapping package is generated based on the mapping contract. At step <NUM>, the mapping package is deployed to a native operating system, off-box host, or guest operating system and process host.

<FIG> depicts a system <NUM> for deploying a custom data model, extended data model, or data model overlay. In some examples, system <NUM> can perform some or all of the steps discussed above in reference to method <NUM> and method <NUM>.

A user may generate a customized data model on a client device <NUM>, which may be a desktop computer, laptop, mobile device, etc., through a mapping interface <NUM>. Mapping interface <NUM> includes various components for generating a customized data model and may also include graphical components, command line components, and various other user experience aspects as will be understood by a person having ordinary skill in the art with the benefit of this disclosure.

Mapping interface <NUM> includes various templates <NUM> and validations <NUM>. Templates <NUM> may include basic data models with specialized functionality based on use case and can be utilized by the user as a basis for further data model customization. Validations <NUM> may include various rules for validating the operational capabilities and/or compatibility of a customized data model. In some examples, validations <NUM> may be updated by one or more network devices <NUM> to include particular validation rules associated with particular network devices <NUM> and respective locally stored data models.

A mapping assistant <NUM> may guide the user in creating a customized data model. For example, where a user has added a particular feature to a customized data model, mapping assistant <NUM> can highlight issues in a resultant data model tree such as naming, inheritance, typing, and other issues. An annotation generator <NUM> receives a finalized customized data model and produces and annotated data model which serves as a mapping contract (e.g., as discussed in method <NUM> and method <NUM> above).

Mapping interface <NUM> may provide the mapping contract to a mapping package generator <NUM>. In some examples, mapping interface <NUM> includes an export command or the like for finalizing the mapping contract and sending it to mapping package generator <NUM>. Mapping package generator <NUM> includes language-specific library plugins <NUM> which, based on data model languages (e.g., C, Python, JavaScript, etc.), can include any needed plugins for generating a mapping package from the mapping contract. Mapping package generator <NUM> provides mapping packages to network device <NUM> either through a direct connection or via network connection.

In particular, network device <NUM> includes data model services <NUM> for processing and deploying received or stored data models and configuration processes <NUM> for interfacing with a device controller <NUM>. Network device <NUM> also communicates with a data store <NUM>, which may store, for example, native data models and/or open standard data models.

Data model services <NUM> includes a model registry <NUM> which manages stored data models (e.g., stored in data store <NUM>) and may associate particular models with one or more different users, for example via namespace and the like. Data model services <NUM> further includes a mapping translation engine <NUM> and a model execution engine <NUM>. Mapping translation engine <NUM> receives mapping packages from mapping package generator <NUM> and may implement appropriate bindings as well as integrate the customized data model as an overlay on locally stored data models retrieved by models registry <NUM>. Model execution engine <NUM> may apply the customized data model to configuration processes <NUM> by interfacing with sub-processes within configurations processes <NUM>. Configuration processes <NUM> includes network configurations <NUM>, application programming interface (API) configurations <NUM> (e.g., REST API, etc.) and microservices configurations <NUM> (e.g., gRPC, etc.).

Once configured by model execution engine <NUM>, and according to the customized data model, configuration processes <NUM> interfaces with device controller <NUM>, for example, to manage network traffic according to the customized data model. For example, certain API calls may trigger particular microservices to generate values sent back as a response or to determine an appropriate forwarding destination and the like.

In some examples, device controller <NUM> may directly interface with a runtime mapping translation engine <NUM>, as depicted in <FIG>. In particular, device controller <NUM> can receive customized data model translations in real-time or near real-time. As a result, translations can be dynamic and so more responsive to changing information, for example, related to routing traffic across a network environment. Device controller <NUM> can provide border gateway protocol (BGP) and intermediate system-intermediate system (IS-IS) protocol information to runtime mapping translation engine <NUM>. In some examples, device controller <NUM> and runtime mapping translation engine <NUM> can be hosted by a shared device (e.g., a server) or may be hosted on different respective devices, either virtual or physical, and communicate via network communications, etc..

Device controller <NUM> can include a core data pipeline <NUM> and mapping translation engine hooks <NUM>. Core data pipeline <NUM> may receive data, for example, over a network and, with mapping translation engine hooks <NUM>, checks for any included data to be translated by runtime mapping translation engine <NUM>. As a result, identified data to be translated can then be provided to runtime mapping translation engine <NUM> for application of a deployed customized data model.

Runtime mapping translation engine <NUM> includes a processor management process <NUM>, a runtime translation process <NUM>, and language package libraries <NUM>. Processor management process <NUM> may provide and manage worker processes for performing operations related to the customized data model. Runtime translation process <NUM> provides translations for the customized data model. Language package libraries <NUM> may provide appropriate bindings and/or plugins based on a combination of device and customized data model factors such as data model language, supported languages by the device, and the like.

Device controller <NUM> may receive configuration information back from runtime mapping translation engine <NUM>. The configuration information may provide particular settings, updates, etc. to be applied to network, API, and microservices protocols. Device controller <NUM> includes a network configurations channel <NUM> for receiving information related to network protocols and settings, an API configurations channel <NUM> for receiving information related to API protocols and settings, and a microservices configurations channel <NUM> for receiving information related to microservices protocols and settings. As a result, device controller <NUM> may apply a customized data model to network traffic in real-time via runtime mapping translation engine <NUM>.

In some examples, a network device <NUM> may include or be associated with a dedicated operating environment for certain customized data model operations, as depicted in <FIG>. For example, either on the same device or different devices, network device <NUM> may communicate with a guest operating system <NUM>, which may be a linux kernel or the like configured for extending locally stored data models according to a customized data model.

Network device <NUM> is substantially similar to network device <NUM> discussed above and includes configuration processes <NUM>, and data model services <NUM> such as mapping translation engine <NUM>, model execution engine <NUM>, and models registry <NUM>. However, network device <NUM> further includes a mapping package container dispatcher <NUM> as part of data model services <NUM>.

Mapping package container dispatcher <NUM> may communicate with guest operating system <NUM>, for example, to deploy workers, containers for the customized data model, and perform various other operations according to the customized data model. Guest operating system <NUM> includes one or more mapping packing containers <NUM>. Each mapping package container includes a mapping extension engine <NUM> for extending a locally stored data model according to the customized data model. Mapping extension engine <NUM> may retrieve local models or components of local models from models registry <NUM>. Mapping extension engine <NUM> includes a worker management process <NUM>, translation processes <NUM>, and language package libraries <NUM>.

For example, workers may be deployed by worker management process <NUM> according to BGP and/or access control list (ACL) extensions. BGP and ACL information may be translated from the customized data model by translation processes <NUM> and using plugins, etc., provided by language package libraries <NUM>.

Although the system shown in <FIG> is one specific network device of the present disclosure, it is by no means the only network device architecture on which the concepts herein can be implemented. For example, an architecture having a single processor <NUM> that handles communications as well as routing computations, etc., can be used. Further, other types of interfaces and media could also be used with the network device <NUM>.

Regardless of the network device's configuration, it may employ a CPU <NUM> and one or more memories or memory modules (including memory <NUM>) configured to store program instructions for the general-purpose network operations and mechanisms for functions described herein to be executed by processor <NUM>.

The network device <NUM> can also include an application-specific integrated circuit (ASIC), which can be configured to perform routing, switching, and/or other operations. The ASIC can communicate with other components in the network device <NUM> via the connection <NUM>, to exchange data and signals and coordinate various types of operations by the network device <NUM>, such as routing, switching, and/or data storage operations, for example.

<FIG> is a schematic block diagram of an example computing device <NUM> that may be used with one or more embodiments described herein e.g., as any of the discussed above or to perform any of the methods discussed above, and particularly as specific devices as described further below. The device may comprise one or more network interfaces <NUM> (e.g., wired, wireless, etc.), at least one processor <NUM>, and a memory <NUM> interconnected by a system bus <NUM>, as well as a power supply <NUM> (e.g., battery, plug-in, etc.).

Network interface(s) <NUM> contain the mechanical, electrical, and signaling circuitry for communicating data over links coupled to a network, e.g., providing a data connection between device <NUM> and the data network, such as the Internet. The network interfaces may be configured to transmit and/or receive data using a variety of different communication protocols. For example, interfaces <NUM> may include wired transceivers, wireless transceivers, cellular transceivers, or the like, each to allow device <NUM> to communicate information to and from a remote computing device or server over an appropriate network. The same network interfaces <NUM> also allow communities of multiple devices <NUM> to interconnect among themselves, either peer-to-peer, or up and down a hierarchy. Note, further, that the nodes may have two different types of network connections <NUM>, e.g., wireless and wired/physical connections, and that the view herein is merely for illustration. Also, while the network interface <NUM> is shown separately from power supply <NUM>, for devices using powerline communication (PLC) or Power over Ethernet (PoE), the network interface <NUM> may communicate through the power supply <NUM>, or may be an integral component of the power supply.

Memory <NUM> comprises a plurality of storage locations that are addressable by the processor <NUM> and the network interfaces <NUM> for storing software programs and data structures associated with the embodiments described herein. The processor <NUM> may comprise hardware elements or hardware logic adapted to execute the software programs and manipulate the data structures <NUM>. An operating system <NUM>, portions of which are typically resident in memory <NUM> and executed by the processor, functionally organizes the device by, among other things, invoking operations in support of software processes and/or services executing on the device. These software processes and/or services may comprise one or more mapping processes <NUM> which, on certain devices, may be used by an illustrative translation process <NUM>, as described herein. Notably, mapping processes <NUM> may be stored and/or retrieved for storage by processor(s) <NUM> via, for example, network interface(s) <NUM> or other processes according to the configuration of device <NUM>.

In summary, a data model can be customized by a user and executed in real-time at a network device. The user provides definitions for the customized data model based on a data model locally stored on the network device. The user provided definitions are used to generate a mapping contract which is processed by a mapping package generator to generate a mapping package. The mapping package can then be processed by a translation engine to dynamically execute a customized data model in real-time.

It will be apparent to those skilled in the art that other processor and memory types, including various computer-readable media, may be used to store and execute program instructions pertaining to the techniques described herein. Also, while the description illustrates various processes, it is expressly contemplated that various processes may be embodied as modules configured to operate in accordance with the techniques herein (e.g., according to the functionality of a similar process). Further, while the processes have been shown separately, those skilled in the art will appreciate that processes may be routines or modules within other processes.

There may be many other ways to implement the subject technology. Various functions and elements described herein may be partitioned differently from those shown without departing from the scope of the subject technology. Various modifications to these embodiments will be readily apparent to those skilled in the art, and generic principles defined herein may be applied to other embodiments. Thus, many changes and modifications may be made to the subject technology, by one having ordinary skill in the art, without departing from the scope of the subject technology.

A reference to an element in the singular is not intended to mean "one and only one" unless specifically stated, but rather "one or more. " The term "some" refers to one or more. Underlined and/or italicized headings and subheadings are used for convenience only, do not limit the subject technology, and are not referred to in connection with the interpretation of the description of the subject technology.

Claim 1:
A method for deploying a customized data model to a network device (<NUM>), the method comprising:
receiving definitions for the customized data model, the definitions related to one or more changes in functionality of a local data model (<NUM>) provided at the network device to configure the network device for managing network traffic;
verifying feature coverage by the network device of the received definitions to determine if the customized data model is compatible with the network device hardware and/or local data model, the verifying comprising determining whether hardware functionality is sufficient for deployment of the customized data model, and/or whether there is a mismatch between the customized data model and the local data model; and
in response to determining compatibility, performing the steps of:
generating a mapping package comprising one or more mappings for mapping the customized data model to the local data model based on the received definitions;
deploying, with a mapping translation engine (<NUM>), the mapping package to the network device to extend and/or augment the local data model stored on the network device to provide the functionality of the customized data model; and
controlling the network device according to the deployed mapping package.