精华内容
下载资源
问答
  • YANG语言标准中文

    万次阅读 2018-01-31 11:13:36
    YANG是一种数据建模语言,被用来为NETCONF,NETCONF远程过程调用,NETCONF Notification操作的配置和状态数据进行建模。 本文档状态 This is an Internet Standards Track document. This document is a product ...

    摘要

    YANG是一种数据建模语言,被用来为NETCONF,NETCONF远程过程调用,NETCONF Notification操作的配置和状态数据进行建模。
    本文档状态

    This is an Internet Standards Track document.

    This document is a product of the Internet Engineering Task Force
    (IETF). It represents the consensus of the IETF community. It has
    received public review and has been approved for publication by the
    Internet Engineering Steering Group (IESG). Further information on
    Internet Standards is available in Section 2 of RFC 5741.

    Information about the current status of this document, any errata,
    and how to provide feedback on it may be obtained at
    http://www.rfc-editor.org/info/rfc6020.
    版权信息

    Copyright (c) 2010 IETF Trust and the persons identified as the
    document authors. All rights reserved.

    This document is subject to BCP 78 and the IETF Trust’s Legal
    Provisions Relating to IETF Documents
    (http://trustee.ietf.org/license-info) in effect on the date of
    publication of this document. Please review these documents
    carefully, as they describe your rights and restrictions with respect
    to this document. Code Components extracted from this document must
    include Simplified BSD License text as described in Section 4.e of
    the Trust Legal Provisions and are provided without warranty as
    described in the Simplified BSD License.

    This document may contain material from IETF Documents or IETF
    Contributions published or made publicly available before November
    10, 2008. The person(s) controlling the copyright in some of this
    material may not have granted the IETF Trust the right to allow
    modifications of such material outside the IETF Standards Process.
    Without obtaining an adequate license from the person(s) controlling
    the copyright in such materials, this document may not be modified
    outside the IETF Standards Process, and derivative works of it may
    not be created outside the IETF Standards Process, except to format
    it for publication as an RFC or to translate it into languages other
    than English.
    1. 介绍

    YANG是一种数据建模语言,被用来为NETCONF,NETCONF远程过程调用,NETCONF Notification操作的配置和状态数据进行建模。

    本文档描述了YANG语言的语法和语义,在一个YANG module中定义的数据模型如何以XML的形式表示,NETCONF如何操作数据。
    2. 关键词

    The keywords “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”,
    “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “NOT RECOMMENDED”, “MAY”, and
    “OPTIONAL” in this document are to be interpreted as described in BCP
    14, [RFC2119].
    3. 术语

    anyxml —— 一种数据节点,能够包含未知的XML格式的数据块。
    augment —— 向之前定义的schema node增加新的schema nodes。
    base type —— 可以被用来继承的数据类型,可以使built-in类型,也可以是派生的类型。
    built-in type —— YANG语言定义的YANG数据类型,比如uint32 或者 string。
    choice —— 一个schema node,其值是多个可选项中的一个。
    configuration data —— 可写入的数据的集合,被用来转变系统的状态【RFC4741】。
    conformance(一致性) —— 一种评估实际上设备在多大程度上服从数据模型的方法。
    container —— 一种内建的数据节点,在data tree中,最多只能有一个实例存在。一个container没有值,不过会包含一些子节点。
    data definition statement —— 一种定义新的数据节点的声明(statement)。可以是container,leaf,leaf-list,list,choice,case,augment,uses,以及anyxml中的一个。
    data model —— 一种表述数据如何展现和访问的数据模型。
    data node(数据节点) —— schema tree中的一个节点,能够在data tree中实例化。可以是container,leaf,leaf-list,list,以及anyxml中的一个。
    data tree —— 由一个设备上的配置和状态数据实例化的树。
    derived type(派生类型) —— 一种从内建数据类型,或者其他派生类型中派生出来的类型。
    device deviation(设备偏差) —— 如实反映设备在实现YANG模块时候的失败情况。
    extension —— 使用非YANG语义声明的扩展。扩展声明定义了新的statement表示这些语义。
    feature —— 一种可选的能够标记模型的某一部分的机制。可以使用feature名作为标签,不过该标签仅仅在支持该feature的设备上才有效。
    grouping —— 一种可重用的schema nodes的集合。该集合可能在定义处的module中被使用,也可能在包含它的modules中使用,还可能在导入它的modules中被使用。grouping声明不是一种数据定义声明,它不会在schema node中定义任何节点。
    identifier —— 通过名字,被用来识别不同种类的YANG items。
    instance identifier —— 在data tree中被用来标记特定的一个节点。
    interior node —— 分层结构中,非leaf node的节点。
    leaf —— 一种数据节点,在data tree中最多只能有一个实例存在。一个leaf节点只能有一个值,并且不能有子节点。
    leaf-list —— 和leaf节点相似,但是定义了一集合的可唯一识别的节点,而非一个节点。其中每一个节点都有值,但是都没有子节点。
    list —— 一种内部的数据节点,在data tree中可能会有多个实例存在。一个list没有值,但是会有一些子节点。
    module —— 一个YANG module定义了一个具有垂直层级结构的节点集,这些节点能够被用于基于NETCONF的operations。如果有一个module的定义,以及该module依赖的其他module的定义,则这个module是自足的,以及“可编译的(compilable)”。
    RPC —— 远程过程调用,在NETCONF协议中使用的。
    RPC operation —— 一种特定的远程过程调用,在NETCONF协议中使用的。也被成为协议操作(protocol operation)。
    schema node —— 在schema tree中的节点。是container,leaf,leaf-list,list,choice,case,rpc,input,output,notification,以及anyxml中的一种。
    schema tree —— module中的特定垂直结构定义(The definition hierarchy specified within a module.)。
    state data(状态数据) —— 系统中的配置数据之外的其他额外数据,比如只读的状态信息,数据统计信息【RFC4741】。
    submodule —— 一种局部的module定义。submodule为所在的module提供了derived types,groupings,data nodes,RPCs,以及notifications。一个YANG module可以由多个submodules组成。
    top-level data node —— 一个数据节点,在该节点和module/submodule声明之间,没有其他的数据节点存在。
    uses —— 这个“uses”声明被用来实例化在grouping声明中定义的schema nodes。这些实例化的节点可能会被扩展以满足特定的需求。
    
    搞不明白feature的具体用法。不知道data tree和schema tree的区别。
    

    3.1 Mandatory Nodes(必须出现的节点)

    一个mandatory node是以下中的:

    “mandatory”声明为“true”的一个leaf,choice,或者anyxml节点。
    “min-elements”声明为大于0的数的一个list,或者leaf-list节点。
    没有“presence”声明的container节点,它里面至少要包含一个mandatory node的子节点。
    
    1. YANG总览
      4.1 功能总览

    YANG是一种被用来为NETCONF协议建模的语言。一个YANG module定义了具有垂直结构的数据,这些数据可以被用做基于NETCONF的operations,比如configuration,state date,RPCs,以及notifications。它使得NETCONF的client和server之间能有完整的数据描述。

    YANG建模得到的数据具备树形结构。其中每一个节点都有一个名字,都有一个值或者一些子节点。YANG为这些节点,以及节点之间的交互提供明确清晰的描述。

    YANG使用modules和submodule进行数据建模。一个module能够从其他外部的modules中导入数据,也可以从submodules中包含数据。YANG定义的垂直结构可以扩展,使得一个module能够增加数据节点给另一个module。这种扩展是有条件的,只有特定条件满足,新的数据节点才会出现。

    YANG模型还能描述数据之上增加的约束,基于垂直结构中其他节点的出现与否,值为多少等等来限制一些节点的出现与赋值。这些约束可以被client或者server强制执行。不过如果要使得内容有效,MUST 双方都要遵守特定的约定。

    YANG定义了一系列的内建数据类型,也有定义新数据类型的类型命名机制。派生数据类型可以通过像range,pattern这样的声明限制其原生数据类型的取值范围,这样的声明在client或者server端都可以执行。它们还能为派生数据类型定义常用用法,比如定义一个string-based类型,包含主机名。

    YANG允许对可重用的grouping中节点的定义。这些groupings中的实例能够通过特定的增强以满足特殊的需求。派生类型以及groupings能够定义在一个module或者submodule中,能够被本地,其他module/submodule导入和使用。

    YANG的垂直数据结构包括了对list的定义。list中包含的每一项都有唯一的key以区分彼此。这样的lists有可能被用户自定义排序或者由系统进行默认排序。对于用户自定义排序的lists来说,operations是为了对列表项进行排序定义的。

    YANG modules可以被转换为等价的XML格式,称为YANG Independent Notation(YIN)(Section 11),这使得相关的应用可以通过XML解析器或者XSLT脚本进行操作。从YANG到YIN的转换是无损的,因此也可以从YIN格式转换为YANG文件。

    YANG试图在高层的数据建模和底层的比特数据编码(bits-on-the-wire encoding)之间追求平衡。YANG module的reader可以查看数据模型的高层视图,同时也能理解在NETCONF operations中,这些数据如何编码。

    YANG是一种可扩展语言,允许标准制定者,设备商,以及个人定义新的声明(statement)。声明的语法使得这些扩展能够以一种自然的方式和标准的YANG 声明共存,同时使得reader能够有效得认知这些新扩展。

    YANG resists the tendency to solve all possible problems, limiting the problem space to allow expression of NETCONF data models, not arbitrary XML documents or arbitrary data models. The data models described by YANG are designed to be easily operated upon by NETCONF operations.

    为了扩大使用范围,YANG和SNMP协议的SMIv2(Structure of Management Information,RFC2578和RFC2579)保持了兼容。基于SMIv2的MIB modules能够以只读的方式自动转换为YANG modules。然而,YANG并不关心如何从YANG转换为SMIv2。

    和NETCONF相似,YANG致力于和设备本身自带的管理机制进行平滑集成。这就使得需要利用设备当前的访问控制机制去保护/暴露数据模型的相应元素。
    4.2 语言总览

    本小节引入了YANG语言中的一些重要结构,这些在后面的章节中,对于理解语言细节能够提供一些帮助。这种方法解决了难以理解的相互联系的YANG概念和声明的复杂关系问题。关于YANG的声明(statement)和语法(syntax)的细节描述可见Section 7。
    4.2.1 Modules和Submodules

    一个module包含了三种类型的声明:

    module-header statement(模块头声明) —— 描述了该module,给出了module相关的信息。
    revision statement(版本声明)—— 描述了该module的历史信息。
    definition statement(定义声明) —— 定义了数据模型的内容部分。
    

    一个NETCONF Server可能会实现多个modules,拥有相同设备数据的多个视图,或者互不相交的多个子集的多个视图。这种情况下,Server可能会选择仅仅实现定义了所有可用数据的一个module。(A NETCONF server may implement a number of modules, allowing multiple views of the same data, or multiple views of disjoint subsections of the device’s data. Alternatively, the server may implement only one module that defines all available data.)

    根据需求,一个module可以被分为多个submodules。而对外来说,依然是单个module,无论内部拥有多少个submodules。

    “include”声明允许一个module或者submodule引用submodules中定义的数据;“import”声明允许引用其他modules中定义的数据。
    4.2.2 数据建模基础(Data Modeling Basics)

    YANG定义了四种用于数据建模的节点类型。在下面的每一个小节中,都有例子展示了YANG语法以及相应的NETCONF XML表达。
    4.2.2.1 Leaf Nodes

    一个leaf node包含了像integer或者string这样的简单数据。它有且仅有一个特定类型的值,并且没有子节点。

    YANG 示例:

    leaf host-name {
    type string;
    description “Hostname for this system”;
    }

    NETCONF XML 示例:

      <host-name>my.example.com</host-name>
    

    “leaf”的声明可以在Section 7.6 中找到。
    4.2.2.2 Leaf-List Nodes

    一个leaf-list是一系列的leaf nodes,每个leaf都有特定类型的值。

    YANG 示例:

    leaf-list domain-search {
     type string;
     description "List of domain names to search";
    

    }

    NETCONF XML 示例:

    high.example.com
    low.example.com
    everywhere.example.com

    1
    2
    3
    4
    

    “leaf-list”的声明可以在Section 7.7 中找到。
    4.2.2.3 Container Nodes

    一个container node用来将相关的节点归总到一个subtree中。一个container node只有子节点,没有值。一个container可能会包含任何类型的任何数量的子节点(包括leafs,lists,leaf-lists以及containers)。

    YANG 示例:

    container system {
    container login {
    leaf message {
    type string;
    description
    “Message given at start of login session”;
    }
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    

    NETCONF XML 示例:



    Good morning

    1
    2
    3
    4
    5
    6
    

    “container”的声明可以在Section 7.5 中找到。
    4.2.2.4 List Nodes

    一个List定义了一系列的列表项(list entries)。每个列表项都像是一个structure或者一个record instance,通过名为“key”的leaf的值唯一确定。一个list能定义多种key leafs,能够包含任意类型的任意数目的子节点(包括leafs,lists,containers)。

    YANG 示例:

    list user {
    key “name”;
    leaf name {
    type string;
    }
    leaf full-name {
    type string;
    }
    leaf class {
    type string;
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    

    NETCONF XML 示例:


    glocks
    Goldie Locks
    intruder


    snowey
    Snow White
    free-loader


    rzell
    Rapun Zell
    tower

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    

    “list”的声明可以在Section 7.8 中找到。
    4.2.2.5 Module示例

    上述的那些声明组合起来能够定义一个简单的module:

    // Contents of “acme-system.yang”
    module acme-system {
    namespace “http://acme.example.com/system“;
    prefix “acme”;

     organization "ACME Inc.";
     contact "joe@acme.example.com";
     description
         "The module for entities implementing the ACME system.";
    
     revision 2007-06-09 {
         description "Initial revision.";
     }
    
     container system {
         leaf host-name {
             type string;
             description "Hostname for this system";
         }
    
         leaf-list domain-search {
             type string;
             description "List of domain names to search";
         }
    
         container login {
             leaf message {
                 type string;
                 description
                     "Message given at start of login session";
             }
    
             list user {
                 key "name";
                 leaf name {
                     type string;
                 }
                 leaf full-name {
                     type string;
                 }
                 leaf class {
                     type string;
                 }
             }
         }
     }
    

    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    

    4.2.3 State Data

    YANG 能够通过“config”声明对state data和configuration data进行建模。当一个节点打上了“config false”的标签,它的子结构就打上了state data的标签,会通过NETCONF的操作,而不是操作。作为其父节点的containers,lists,以及key leafs也会上报,以给这个state data明确的上下文环境。

    不清楚为什么还会有key leafs。
    

    在下面的例子中,每个interface都定义了两个leafs,一个是configured speed(配置速率),另一个是observed speed(观察速率)。观察速率是不可配置的,所以它能通过NETCONF的操作获取,但是不能通过操作获取,也不能通过操作操作。

    list interface {
    key “name”;

     leaf name {
         type string;
     }
     leaf speed {
         type enumeration {
             enum 10m;
             enum 100m;
             enum auto;
         }
     }
     leaf observed-speed {
         type uint32;
         config false;
     }
    

    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    

    4.2.4 Built-in Types

    和一些编程语言类似,YANG也有一系列的内置类型。下面的表格就总结了在Section 9描述的内置数据类型:

    +———————+————————————-+
    | Name | Description |
    +———————+————————————-+
    | binary | Any binary data |
    | bits | A set of bits or flags |
    | boolean | “true” or “false” |
    | decimal64 | 64-bit signed decimal number |
    | empty | A leaf that does not have any value |
    | enumeration | Enumerated strings |
    | identityref | A reference to an abstract identity |
    | instance-identifier | References a data tree node |
    | int8 | 8-bit signed integer |
    | int16 | 16-bit signed integer |
    | int32 | 32-bit signed integer |
    | int64 | 64-bit signed integer |
    | leafref | A reference to a leaf instance |
    | string | Human-readable string |
    | uint8 | 8-bit unsigned integer |
    | uint16 | 16-bit unsigned integer |
    | uint32 | 32-bit unsigned integer |
    | uint64 | 64-bit unsigned integer |
    | union | Choice of member types |
    +———————+————————————-+

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    

    “type”的声明可以在Section 7.4 中找到。
    4.2.5 Derived Types(typedef)

    YANG能够使用“typedef”声明从基本类型中定义派生类型。一个基本类型可以是内置类型或者派生类型。

    YANG 示例:

    typedef percent {
    type uint8 {
    range “0 .. 100”;
    }
    description “Percentage”;
    }

    leaf completed {
    type percent;
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    

    NETCONF XML 示例:

    20

    1
    2
    

    “typedef”的声明可以在Section 7.3 中找到。
    4.2.6 可重用的节点组(grouping)

    可以使用“grouping”声明将一组节点放到可重用的集合中去。一个grouping定义了节点的集合,该集合可以使用“uses”声明实例化:

    YANG 示例:
    grouping target {
    leaf address {
    type inet:ip-address;
    description “Target IP address”;
    }
    leaf port {
    type inet:port-number;
    description “Target port number”;
    }
    }

    container peer {
    container destination {
    uses target;
    }
    }

    1
    2
    3
    4
    5
    6
    

    NETCONF XML 示例:



    192.0.2.1

    830

    1
    2
    3
    4
    5
    6
    7
    

    grouping可以根据它被调用时候的用途进行优化,重写特定的声明来覆盖原来grouping的定义。在下面的例子中,description被重定义了:

    container connection {
    container source {
    uses target {
    refine “address” {
    description “Source IP address”;
    }
    refine “port” {
    description “Source port number”;
    }
    }
    }
    container destination {
    uses target {
    refine “address” {
    description “Destination IP address”;
    }
    refine “port” {
    description “Destination port number”;
    }
    }
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    

    “grouping”的声明可以在Section 7.11 中找到。
    4.2.7 choice

    YANG能够使用“choice”和“case”声明分离互不相容,不能同时出现的节点。“choice”声明包含了多个“case”声明,定义了不能同时出现的schema nodes的集合。每个“case”声明都可能包含多个节点,但是每个节点都应该只在一个“case”中出现。

    当一个case元素被创建,其他所有cases的元素都会被隐式删除。设备要强制执行这个约束,以防止出现配置的不协调。

    “choice”和“case”节点只会出现在schema tree中,不能出现在data tree或者NETCONF message。

    YANG 示例:

    container food {
    choice snack {
    case sports-arena {
    leaf pretzel {
    type empty;
    }
    leaf beer {
    type empty;
    }
    }
    case late-night {
    leaf chocolate {
    type enumeration {
    enum dark;
    enum milk;
    enum first-available;
    }
    }
    }
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    

    NETCONF XML 示例:




    1
    2
    3
    4
    5
    

    “choice”的声明可以在Section 7.9 中找到。
    4.2.8 扩展数据模型(augment)

    YANG允许一个模块将额外的节点插入到数据模型中,包括当前的module(以及它的submodule)或者一个外部的module。这一点是很有用的,比如对于设备商来说,需要在标准数据模型中插入设备商指定的参数。

    “augment”声明定义了在数据模型树形结构中,新的节点插入的位置。“when”声明了新节点生效的时间。

    YANG 示例:

    augment /system/login/user {
    when “class != ‘wheel’”;
    leaf uid {
    type uint16 {
    range “1000 .. 30000”;
    }
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    

    这个例子定义了一个“uid”的leaf node,该node仅在user的class不等于wheel的时候才有效。

    如果一个module增强了另一个module,则数据的XML表示将会影响增强它的module的前缀。比如,如果上一个例子的augment是放在一个“other”前缀的module中,则其XML看起来应该是这样的:

    NETCONF XML 示例:


    alicew
    Alice N. Wonderland
    drop-out
    1024

    1
    2
    3
    4
    5
    6
    7
    

    “augment”的声明可以在Section 7.15中找到。
    4.2.9 RPC定义

    YANG也能定义NETCONF中的RPCs。RPC中的operations’ name,输入参数,和输出参数都可以通过YANG的数据定义声明进行建模。

    YANG 示例:

    rpc activate-software-image {
    input {
    leaf image-name {
    type string;
    }
    }
    output {
    leaf status {
    type string;
    }
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    

    NETCONF XML 示例:

    展开全文
  • YANG模型

    千次阅读 2019-08-29 20:03:37
    YANG的解读(一) https://www.jianshu.com/p/ca7f5fe11fae https://www.sdnlab.com/18066.html https://blog.csdn.net/dolphin98629/article/details/54906208 在研究netconf的时候,YANG(RFC6020)是一定绕...

    对YANG的解读(一)

    https://www.jianshu.com/p/ca7f5fe11fae

    https://www.sdnlab.com/18066.html

    https://blog.csdn.net/dolphin98629/article/details/54906208

    在研究netconf的时候,YANG(RFC6020)是一定绕不过的。花了一些时间看RFC6020,有一点初步的理解,记录下来方便后面查看。

    1 为什么要有YANG

    netconf需要对设备的配置(configuration)和状态(state)做操作,例如编辑配置,获取状态,因此需要一种语言来对configuration和state进行建模,甚至连“操作”也可以通过YANG来建模。建好的模型,最后以XML的形式进行实例化。打个比方,我需要向领导请假,领导说你写个请假单,包含请假人的姓名,请假的起止时间,请假事由和代理人。于是我做了一个表格,包含了上述要求,并根据实际情况填入了真实信息。那么领导的描述,就可以理解为“建模”,而我最后提交的填好内容的表格,就是将模型实例化了。

    2 建模需要什么呢

    如果要建模,一定需要一些基础架构,然后将要建立的模型用这些基础架构拼接出来。那么YANG提供了哪些架构呢?

    2.1 module和submodule

    module的header主要是一些描述信息,而body就是data model定义的地方。module可以分为submodule。模块化的好处就是方便引用。

    2.2 Data Modeling Basics

    这时候要敲敲黑板,因为重点来喽。这里介绍最最基本的四种建模架构。

    2.2.1 Leaf Nodes

    一个leaf node包含且只包含一个value,可以是数字或是字符串,具体是什么,看关键字"type"后面跟什么。leaf node下面不能挂子节点。
    例如:

       YANG Example:
    
           leaf host-name {
               type string;
               description "Hostname for this system";
           }
    -----------------------
       NETCONF XML Example:
    
           <host-name>my.example.com</host-name>
    

    此处用YANG定义了一个名为host-name的leaf,它包含对自己的description,有一个string类型的值。那么当用XML实例化这个leaf的时候,就需要对host-name进行具体的赋值。换句话说,YANG是挖坑的,XML是填坑的,但是XML填坑用的材料的“形状”,要和YANG定义的一样。

    2.2.2 Leaf-List Nodes

    与上面的Leaf Nodes“一字之差”,多了一个“-list”。可以认为Leaf-List Nodes表示的是一个“数组”,“数组”中的元素的值的type必须保持一致,而且不能重复。
    例如:

       YANG Example:
    
         leaf-list domain-search {
             type string;
             description "List of domain names to search";
         }
    -----------------------
       NETCONF XML Example:
    
         <domain-search>high.example.com</domain-search>
         <domain-search>low.example.com</domain-search>
         <domain-search>everywhere.example.com</domain-search>
    

    和leaf node一样,它也只定义一个value,但是可以有一系列同类型的值。例子中<domain-serarch>的值有多个,但是定义和类型都是统一的。

    2.2.3 Container Nodes

    “Container”可以翻译成“集装箱”。真正有价值的,是集装箱里面装的货物,而不是集装箱本身。但是如果没有集装箱,那么里面的货物就散了。
    Container的作用就是将数据层次化组织起来,呈现出subtree的样式。特别需要注意的是:
    (1)一个空的集装箱也是能“卖钱”的,因为毕竟是铁皮做的,但是一个container自身是没有“value”的;
    (2)一个集装箱容量是有限的,但是一个container可以装多少node并没有限制,而且这些node可以在leaf/list/leaf-list甚至是container(想起了俄罗斯套娃)中任意选取。
    例如:

    YANG Example:
    
         container system {
             container login {
                 leaf message {
                     type string;
                     description
                         "Message given at start of login session";
                 }
             }
         }
    
    -----------------------
       NETCONF XML Example:
    
         <system>
           <login>
             <message>Good morning</message>
           </login>
         </system>
    

    container system里面装了一个container login,然后login里面有一个leaf node,就是类型为string的“message”。

    2.2.4 List Nodes

    一个List node可以包含多个child node,而且这些node可以在leaf/leaf-list/container中任意选取。List必须指明这些child中的一个node为key。
    例如:

    YANG Example:
    
         list user {
             key "name";
             leaf name {
                 type string;
             }
             leaf full-name {
                 type string;
             }
             leaf class {
                 type string;
             }
         }
    -----------------------
    NETCONF XML Example:
    
         <user>
           <name>glocks</name>
           <full-name>Goldie Locks</full-name>
           <class>intruder</class>
         </user>
         <user>
           <name>snowey</name>
           <full-name>Snow White</full-name>
           <class>free-loader</class>
         </user>
         <user>
           <name>rzell</name>
           <full-name>Rapun Zell</full-name>
           <class>tower</class>
         </user>
    
    

    定义了一个名为“user”的list,这个list中包含三个leaf:name/full-name/class。其中name被指定为key。实例化的时候,key的值(也就是"name"的值)是必须不同的,其它的值(full-name/class)没有这个要求。随后xml实例化了三个user,都包含YANG定义的name/full-name/class,而且name都是不同的。

    2.2.5 Combined Module

    RFC中给出了一个综合上述四种node的混合模式的例子如下:

    // Contents of "acme-system.yang"
         module acme-system {
             namespace "http://acme.example.com/system";
             prefix "acme";
    
             organization "ACME Inc.";
             contact "joe@acme.example.com";
             description
                 "The module for entities implementing the ACME system.";
    
             revision 2007-06-09 {
                 description "Initial revision.";
             }
    
             container system {
                 leaf host-name {
                     type string;
                     description "Hostname for this system";
                 }
    
                 leaf-list domain-search {
                     type string;
                     description "List of domain names to search";
                 }
    
                 container login {
                     leaf message {
                         type string;
                         description
                             "Message given at start of login session";
                     }
    
                     list user {
                         key "name";
                         leaf name {
                             type string;
                         }
                         leaf full-name {
                             type string;
                         }
                         leaf class {
                             type string;
                         }
                     }
                 }
             }
         }
    -----------------------
    NETCONF XML Example:
    
    <system>
      <host-name>myyang.com</host-name>
      <domain-search>high.example.com</domain-search>
      <domain-search>low.example.com</domain-search>
      <domain-search>everywhere.example.com</domain-search>
      <login>
        <message>Good Morning</message>
        <user>
           <name>glocks</name>
           <full-name>Goldie Locks</full-name>
           <class>intruder</class>
         </user>
         <user>
           <name>snowey</name>
           <full-name>Snow White</full-name>
           <class>free-loader</class>
         </user>
         <user>
           <name>rzell</name>
           <full-name>Rapun Zell</full-name>
           <class>tower</class>
         </user>
       </login>
    </system>
    

    对YANG module的解读:

    • module的名字是acme-system
    • namespace是用来唯一标识这个YANG模型与其它YANG模型不同
    • prefix是namespace的一种简写
    • organization/contact/description都是用来描述相关信息
    • revison描述版本信息,可以有多个revision(一般记录版本更新的内容)
    • module中包含一个container system
    • container system包含一个leaf(host-name),一个leaf-list(domain-search)和一个container login
    • container login包含一个leaf(message),和一个list(user)

    下面的XML只要按照YANG Module的规定,实例化即可。

    2.3 State Data

    netconf需要区分configuration data和state(状态) data,在YANG建模的时候,对于state data需要加上"config false".例如:

         list interface {
             key "name";
    
             leaf name {
                 type string;
             }
             leaf speed {
                 type enumeration {
                     enum 10m;
                     enum 100m;
                     enum auto;
                 }
             }
             leaf observed-speed {
                 type uint32;
                 config false;
             }
         }
    

    好吧,10m/100m确实暴露了这篇RFC的“年龄”,现在交换机的端口带宽已经可以达到100G甚至更高了。在list interface中。speed的value type是枚举类型,就是说实例化的时候只能从这里列出的三种中选择一个。对于leaf observed-speed,因为包含"config false",因此这个leaf记录的是state value,不可以配置。对应于netconf的操作,leaf speed可以<get-config>,而leaf observed-speed只能<get>。

    2.4 Build-in Type

    前面给leaf或是leaf-list定义类型的时候举的例子,type后面跟的都是string。实际上string只是YANG build-in(内建)数据类型中的一种。下面罗列一下YANG所有的build-in types

    
           +---------------------+-------------------------------------+
           | Name                | Description                         |
           +---------------------+-------------------------------------+
           | binary              | Any binary data                     |
           | bits                | A set of bits or flags              |
           | boolean             | "true" or "false"                   |
           | decimal64           | 64-bit signed decimal number        |
           | empty               | A leaf that does not have any value |
           | enumeration         | Enumerated strings                  |
           | identityref         | A reference to an abstract identity |
           | instance-identifier | References a data tree node         |
           | int8                | 8-bit signed integer                |
           | int16               | 16-bit signed integer               |
           | int32               | 32-bit signed integer               |
           | int64               | 64-bit signed integer               |
           | leafref             | A reference to a leaf instance      |
           | string              | Human-readable string               |
           | uint8               | 8-bit unsigned integer              |
           | uint16              | 16-bit unsigned integer             |
           | uint32              | 32-bit unsigned integer             |
           | uint64              | 64-bit unsigned integer             |
           | union               | Choice of member types              |
           +---------------------+-------------------------------------+
    

    2.5 Derived Type

    在实际建模中,上述的type肯定是不够的。YANG允许用户使用typedef来定义自己需要的type,可以基于build-in type或是另外一个派生的type。

    例如需要一个描述百分比的type:

       YANG Example:
    
         typedef percent {
             type uint8 {
                 range "0 .. 100";
             }
             description "Percentage";
         }
    
         leaf completed {
             type percent;
         }
    -----------------------
       NETCONF XML Example:
    
         <completed>20</completed>
    
    • 通过typedef定义了新的type"percent",基于uint8(0-255的无符号整数),并进一步限制取值范围为[0,100]
    • 定义了leaf completed(完成百分比),使用的type正是上面定义的percent
    • XML实例化completed时候给出的数值是20,符合percent的type定义
    • 如果netconf交互的时候,completed传的数值如果不符合YANG的描述(例如小数/负数/200),会因为无法通过模型check而被拒绝

    2.6 Reusable Node Groups (grouping)

    grouping其实不是一种数据类型,它存在的意义只是方便在“编程”的时候被引用。所以它本身是没有value的。grouping可以在本module被引用,或是被其它module引用。

    grouping可以包含

                     +--------------+---------+-------------+
                     | substatement | section | cardinality |
                     +--------------+---------+-------------+
                     | anyxml       | 7.10    | 0..n        |
                     | choice       | 7.9     | 0..n        |
                     | container    | 7.5     | 0..n        |
                     | description  | 7.19.3  | 0..1        |
                     | grouping     | 7.11    | 0..n        |
                     | leaf         | 7.6     | 0..n        |
                     | leaf-list    | 7.7     | 0..n        |
                     | list         | 7.8     | 0..n        |
                     | reference    | 7.19.4  | 0..1        |
                     | status       | 7.19.2  | 0..1        |
                     | typedef      | 7.3     | 0..n        |
                     | uses         | 7.12    | 0..n        |
                     +--------------+---------+-------------+
    
    

    例如:

       YANG Example:
    
         grouping target {
             leaf address {
                 type inet:ip-address;
                 description "Target IP address";
             }
             leaf port {
                 type inet:port-number;
                 description "Target port number";
             }
         }
    
         container peer {
             container destination {
                 uses target;
             }
         }
    -----------------------
       NETCONF XML Example:
    
         <peer>
           <destination>
             <address>192.0.2.1</address>
             <port>830</port>
           </destination>
         </peer>
    
    

    回想一下,当一台主机对外提供服务的时候,客户端需要知道提供服务主机的的IP和端口信息。所以这边可以定义一个grouping target,在里面定义leaf address和leaf port。下面的container peer来uses(调用grouping的关键字)这个grouping。当对<peer>实例化的时候,就需要将grouping target中包含的address和port都进行赋值。这里的830端口,是在RFC6242(Using the NETCONF Protocol over Secure Shell)中定义的基于ssh的netconf服务端口。

    这里的users可以理解为copy,即把grouping的整个内容都复制到了这个schema tree。grouping本身是没有绑定到任何namespace的,直到某个module uses了这个grouping,那么这个grouping就被绑定到这个module了。

    grouping还有一个非常好用的特性就是refine,例如要建立连接,既需要server的IP+port,也需要client的IP+port。因为这两个的数据结构是完全一样的,所以可以复用,并用更准确的description来覆盖grouping定义时候设置的description。

       YANG Example:
    
            container connection {
             container source {
                 uses target {
                     refine "address" {
                         description "Source IP address";
                     }
                     refine "port" {
                         description "Source port number";
                     }
                 }
             }
             container destination {
                 uses target {
                     refine "address" {
                         description "Destination IP address";
                     }
                     refine "port" {
                         description "Destination port number";
                     }
                 }
             }
         }
    

    2.7 Choices

    "choice"+"case"用来描述互斥的内容。一个choice可以包含多个case,每个case可以包含多个node。一般来说在一个choice里,一个case下面的node不应该和其他case下面的node重复。

    在YANG模型和schema中可以看到choice下的所有case,而当对它实例化之后,只会出现一个case下面的nodes了。例如

       YANG Example:
    
         container food {
           choice snack {
               case sports-arena {
                   leaf pretzel {
                       type empty;
                   }
                   leaf beer {
                       type empty;
                   }
               }
               case late-night {
                   leaf chocolate {
                       type enumeration {
                           enum dark;
                           enum milk;
                           enum first-available;
                       }
                   }
               }
           }
        }
    -----------------------
       NETCONF XML Example:
    
         <food>
           <pretzel/>
           <beer/>
         </food>
    

    2.8 Extending Data Models (augment)

    YANG允许向data module插入新的节点。这是一个非常有用的特性,例如厂商想在公共yang上插入自己的特殊参数,那么augment就可以实现这个需求。"when"后面跟的是条件,即为满足这个条件,就插入新的node。例如

    
       YANG Example:
    
         augment /system/login/user {
             when "class != 'wheel'";
             leaf uid {
                 type uint16 {
                     range "1000 .. 30000";
                 }
             }
         }
    -----------------------
       NETCONF XML Example 1:
    
         <user>
           <name>alicew</name>
           <full-name>Alice N. Wonderland</full-name>
           <class>drop-out</class>
           <other:uid>1024</other:uid>
         </user>
    -----------------------
       NETCONF XML Example 2:
    
         <user>
           <name>jerryr</name>
           <full-name>Jerry K. Roma</full-name>
           <class>wheel</class>
         </user>
    

    Example 1中因为class不是"wheel",因此插入uid; Example 2中class是"wheel",所以不插入uid。

    2.9 RPC Definitions

    YANG可以用来定义netconf的rpc,包括rpc输入的参数,输出的参数,例如:

       YANG Example:
    
         rpc activate-software-image {
             input {
                 leaf image-name {
                     type string;
                 }
             }
             output {
                 leaf status {
                     type string;
                 }
             }
         }
    -----------------------
       NETCONF XML Example:
    
         <rpc message-id="101"
              xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
           <activate-software-image xmlns="http://acme.example.com/system">
             <image-name>acmefw-2.3</image-name>
          </activate-software-image>
         </rpc>
    
         <rpc-reply message-id="101"
                    xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
           <status xmlns="http://acme.example.com/system">
             The image acmefw-2.3 is being installed.
           </status>
         </rpc-reply>
    

    定义一种叫做"activate-software-image"的rpc。当Client发送rpc的时候,需要加上image-name,交换机发回rpc-reply的时候,需要加上activate的结果,本例中可以看到操作是成功了。

    2.10 Notification Definitions

    Notification是一种通告机制,当交换机上出现特性event(事件),交换机会主动发给已经建立netconf连接并订阅了Notification的client。YANG可以定义notification,例如

       YANG Example:
    
         notification link-failure {
             description "A link failure has been detected";
             leaf if-name {
                 type leafref {
                     path "/interface/name";
                 }
             }
             leaf if-admin-status {
                 type admin-status;
             }
             leaf if-oper-status {
                 type oper-status;
             }
         }
    -----------------------
       NETCONF XML Example:
    
         <notification
             xmlns="urn:ietf:params:netconf:capability:notification:1.0">
           <eventTime>2007-09-01T10:00:00Z</eventTime>
           <link-failure xmlns="http://acme.example.com/system">
             <if-name>so-1/2/3.0</if-name>
             <if-admin-status>up</if-admin-status>
             <if-oper-status>down</if-oper-status>
           </link-failure>
         </notification>
    

    这样无论是接口的admin状态(shutdown或是no shutdonw),还是链路状态(down/up)发送改变的时候,都可以发送notification给client,并且带上了当前的状态信息。

    3 学以致用

    上面罗列了很多YANG语言建模的细节,但是还远远没有列全。但是如果仔细看了上面的内容,见到yang模型应该不会完全手足无措了。例如下面列一个华为的huawei-netconf.yang来体会一下

    /*
    Copyright (C) 2013-2017 Huawei Technologies Co., Ltd. All rights reserved.
    */
    module huawei-netconf {
      namespace "http://www.huawei.com/netconf/vrp/huawei-netconf";
      prefix netconf;
      include huawei-netconf-type;
      include huawei-netconf-authorization;
      include huawei-netconf-notification;
      include huawei-netconf-authorization-type;
      include huawei-netconf-notification-type;
      
      organization
        "Huawei Technologies Co.,Ltd.";
      contact
        "Huawei Industrial Base Bantian, Longgang Shenzhen 518129                    
            People's Republic of China                    
            Website: http://www.huawei.com Email: support@huawei.com";
      description
        "The NETCONF protocol defines a simple mechanism through which a network device can be managed, configuration data information can be retrieved, and new configuration data can be uploaded and manipulated.";
      revision 2017-03-23 {
        description
          "Functions supported by the schema are added to the YANG file.";
        reference
          "Huawei private.";
      }
      revision 2013-01-01 {
        description
          "Init revision";
        reference
          "Huawei private.";
      }
      container netconf {
        description
          "The NETCONF protocol defines a simple mechanism through which a network device can be managed, configuration data information can be retrieved, and new configuration data can be uploaded and manipulated.";
        container netconfCapabilitys {
          config false;
          description
            "NETCONF capability list.";
          list netconfCapability {
            key "capabilityName version";
            config false;
            description
              "NETCONF capability.";
            leaf capabilityName {
              type netconfNcaCapability;
              config false;
              description
                "Name of the NETCONF capability.";
            }
            leaf version {
              type netconfCapabilityVersion;
              config false;
              description
                "Capability version number.";
            }
            leaf scope {
              type netconfCapabilityScope;
              config false;
              description
                "Scope of the capability.";
            }
          }
        }
        container authorization {
          description
            "NETCONF authorization.";
          uses netconf:netconf_authorization_type;
        }
        container notification {
          config false;
          description
            "notification";
          uses netconf:netconf_notification_type;
        }
        container operationLogSwitch {
          description
            "Switch for RPC oper log.";
          leaf get {
            type boolean;
            description
              "Get oper type.";
          }
        }
      }
    }
    

    小礼物走一走,来简书关注我

    展开全文
  • 2048 Number puzzle game 6.46

    2015-01-10 02:12:41
    操作系统Android ...毋庸置疑,《2048 Number puzzle game》就是这样一款适用于Android平台上风靡有趣的益智类游戏,完美兼容于触屏设备,如果你正需要这样一款游戏来开动一下脑筋的话,那么就赶紧下载试试吧!
  • YANG模型、语言和工具简述

    千次阅读 2018-01-29 10:43:06
    NETCONF简介 NETCONF协议是一种最新的基于XML的...YANG模型和语言 YANG(Yet Another Next Generation ) YANG语法略 YANG文件举略 网管的NETCONF接口中的 YANG 业务bean到xml字符流的转换: Service Bea
    1. NETCONF简介

    NETCONF协议是一种最新的基于XML的网络配置和管理协议。该协议提出了一整套对于网络设备的配置信息和状态信息进行管理的机制。

    1. YANG模型和语言

    YANG(Yet Another Next Generation )

    YANG语法略

    YANG文件举略

    1. 网管的NETCONF接口中的 YANG

    业务bean到xml字符流的转换:

    Service Bean Object—(业务编码适配)—>YANG Bean Object—(只要调用YANG Bean Object接口)—>XML String Content

    网管生成中间YANG Class的两条路线:

    YANG文件—(com.tailf.jnc工具pyang)—> YANG Bean Class

    YANG文件—(rosng工具)—> XSD文件—(Apach xmlbeans工具)—>YANG Bean Class

    1. OpenDaylight中的 YANG

    OpenDaylight 对YANG说明如下:

    “MD-SALRESTCONF Northbound APIs

    Yang models are used in the MD-SAL and in MD-SAL-based applications to define all APIs: inter-component APIs, plugin APIs, northbound APIs, etc. Yang models are used to generate Java APIs at compile time with OpenDaylight Yang Tools and to render REST APIs at run time according to the RESTCONF specification. Plugins designed for MD-SAL define yang models for their northbound REST APIs, which are then exposed to applications via an MD-SAL RESTCONF adapter.”

    结合网管中的应用例子和OpenDaylight中的MD-SAL例子PingService https://wiki.opendaylight.org/view/Ping 可以知:

    1、ODL中只是借用Yang模型和工具来定义全部的API:Componet之间、plugin、北向等API,使得这种接口和AD-SAL REST接口相比更抽象,符合模型驱动(MD)的思想。

    2、Yang模型和工具就是实现XML字符信息和ODL内部Bean Object之间的转换,无论从可扩展性、耦合、开发效率上都有优势。

    3、前期研究可以不关心这个,因为暂时可以用AD-SAL RESTAPI。

    术语

    l anyxml:包含未知XML数据块的数据节点

    l augment:向已存在的结构节点添加新的结构节点

    l Base type:一种既可能是内置类型又可能是另一种派生类型的派生类型

    l Built-in type:用YANG语言定义的YANG数据类型,如uint32和string

    l Choice:仅有一个有效标志替换的结构节点(A schema node where only one of a number of identified alternatives is valid.)

    l Configuration data:用来从初始默认的状态转换到当前状态的一组可写数据

    l Conformance(一致性):衡量设备遵循数据模型准确度

    l Container(容器):在数据树中至多存在一个实例的内部数据节点。容器没有值,但是包含一组子节点。(An interior data node that exists in at most one instance in the data tree. A container has no value, but rather a set of child nodes.)

    l Data definition statement:定义新数据节点的语句。如:Container,leaf,leaf-list,list,choice,case,augment,uses,anyxml。

    l Data model:描述数据如何表示和访问的数据模型

    l Data node:结构树中的一个节点,能在数据树中实例化。如:container,leaf,leaf-list,list,anyxml。

    l Data tree:设备中的配置和状态数据的实例化树

    l Derived type:从内置类型派生出来的派生类型(如:uint32)或者其他派生类型。

    l Device deviation(设备偏差):设备实现模块故障(A failure of the device to implement the module faithfully.)

    l Extension:non-YANG语义语句扩展。扩展语句定了新的语句来表达新的语义。

    l Feature:一种标记一部分模块作为可选的机制。可用特性名标记定义,但这只在支持这种特性的的设备上合法。

    l Grouping:可复用的结构节点,可在本地模块、包含该节点的模块和其他从该节点导入的模块中使用。Grouping语句并不是数据定义语句,因此并没有在结构树中定义任何节点。

    l Identifier(标识符):通过命名来区分和确定不同种类的YANG项目

    l Instance identifier:在数据树中确定实际节点的机制。

    l Interior node(内部节点):有层次结构的节点,但不是叶子节点。

    l Leaf:在数据树中至多存在一个实例的数据节点。叶子节点有值,但是不包含子节点(区别于container)

    l Leaf-list:类似于叶子节点,但leaf-list定义了一组唯一标志的节点而不是单一节点。每个节点都有值但没有子节点。

    l List:可在数据树中存在多个实例的数据节点。List中没有值但是有一组子节点。

    l Module:YANG模块中定义的具有层次化结构的节点,能进行基于NERCONF的操作。该节点定义的和由该节点导入或从任何地方包含进来的,模块是可以自包含和可编译的。(With its definitions and the definitions it imports or includes from elsewhere, a module is self-contained and “compilable”.)

    l RPC:远程过程调用,在NETCONF中使用。(A specific Remote Procedure Call, as used within the NETCONF protocol.)

    l RPC operation:特定的RPC,也叫做一次协议操作。

    l Schema node:结构树中的一个节点。如:container,leaf,leaf-list,list,choice,case,rpc,input,output,notification,anyxml。

    l Schema node identifier:用于识别结构树中的特定的节点的机制。

    l Schema tree:模块中特定的层次及结构定义。(The definition hierarchy specified within a module.)

    l State data:系统中除配置数据以外的额外数据,如:只读状态信息和收集统计信息。

    l Submodule:部分模块定义,由derived types,grouping,data nodes,RPCs,notifications组成的模块。YANG模块可以由多个子模块构成。

    l Top-level data node:一种数据节点,在该节点和某个模块或子模块声明之间没有其他数据节点。

    l Uses:uses语句被用来实例化一组在grouping语句中定义的结构节点,实例化的节点可以进一步的完善和扩充,以适应其他任何特定的需求。

    展开全文
  • 详情: 在用vue脚手架写项目的时候,用npm run serve启动服务,报错Error: ENOSPC: System limit for number of file watchers reached 解决办法 原因:文件监视程序的系统产生了限制,达到了默认的上限,需要增加...

    问题背景

    系统: deepin
    详情: 在用vue脚手架写项目的时候,用npm run serve启动服务,报错Error: ENOSPC: System limit for number of file watchers reached

    解决办法

    原因:文件监视程序的系统产生了限制,达到了默认的上限,需要增加限额。
    查看限额
    cat /proc/sys/fs/inotify/max_user_watch

    临时增加限额

    sudo sysctl fs.inotify.max_user_watches=524288 
    sudo sysctl -p
    

    永久增加限额

    echo fs.inotify.max_user_watches = 524288 | sudo tee -a /etc/sysctl.conf 
    sudo sysctl -p
    
    展开全文
  • YANG的解读(一)

    2020-04-09 08:33:57
    在研究netconf的时候,YANG(RFC6020)是一定绕不过的。花了一些时间看RFC6020,有一点初步的理解,记录下来方便后面查看。 1 为什么要有YANG netconf需要对设备的配置(configuration)和状态(state)做操作,例如编辑...
  • yang文件语法格式

    千次阅读 2018-12-10 15:17:00
    前言 NETCONF(Network Configuration Protocol),该协议的配置功能非常强大...其中,内容层是唯一没有标准化的层,于是一种新的建模语言YANG产生了,它的目标是对NETCONF数据模型、操作进行建模,覆盖NETCONF协议的...
  • YANG的解读

    千次阅读 2019-06-19 08:08:23
    1 为什么要有YANG netconf需要对设备的配置(configuration)和状态(state)做操作,例如编辑配置,获取状态,因此需要一种语言来对configuration和state进行建模,甚至连“操作”也可以通过YANG来建模。建好的模型,...
  • 我有以下SQL查询:selectID, COLUMN1, COLUMN2from(select ID, COLUMN1, COLUMN2, row_number() over (order by 2 DESC) NO from A_TABLE)whereNO between 0 and 100我想要做的是选择查询的前100条记录select ID, ...
  • RFC6020 - YANG语言标准中文

    万次阅读 多人点赞 2016-08-05 14:49:04
    YANG - A Data Modeling Language for the Network Configuration Protocol (NETCONF)
  • YANG学习笔记及OpenDayLight中toaster示例

    千次阅读 2014-08-05 09:10:10
    YANG是一种为NETCONG 协议模块化数据的语言,YANG模块定义了可被基于NETCONF操作使用的层次化结构的数据它提供了NETCONF客户端和服务器之间完全的数据描述。 一个模块可以从其他节点中导入(impor
  • NETCONF YANG语言文件语法格式:https://blog.csdn.net/Rong_Toa/article/details/104354287 ... yang-version 1.1; namespace "urn:o-ran:interfaces:1.0"; prefix "o-ran-int"; import i...
  • NETCONF YANG语言文件语法格式

    千次阅读 2020-02-17 11:01:24
    NETCONF(Network Configuration Protocol),该协议的配置功能非常...其中,内容层是唯一没有标准化的层,于是一种新的建模语言YANG产生了,它的目标是对NETCONF数据模型、操作进行建模,覆盖NETCONF协议的操作层和...
  • yang标准翻译

    千次阅读 2018-02-22 15:25:23
    (A NETCONF server may implement a number of modules, allowing multiple views of the same data, or multiple views of disjoint subsections of the device’s data. Alternatively, the server may implement...
  • 原题网址:https://leetcode.com/problems/strobogrammatic-number-ii/ ...A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down). Find all strobogrammati
  • number输入框禁止键盘输入

    千次阅读 2018-10-12 23:53:56
    不用js,实现从后台获取物品剩余数量,限制用户非法购买 &...number" onkeydown="return false;" max="${rest}" min="1" value="1"&gt;  
  • 之前的方法是利用group by 来进行分组的方法来过滤,但自从SQL 2005开始软件加入了一个新的函数 ROW_NUMBER, 在消除重复行的时候就可以利用此函数。 ROW_NUMBER ( ) OVER ( [ PARTITION BY value_expression ,...
  • Any binary data | | bits | A set of bits or flags | | boolean | "true" or "false" | | decimal64 | 64-bit signed decimal number | | empty | A leaf that does not have any value | | enumeration | One of...
  • ODL Yang UI界面下发流表VM实验环境Tips1Tips2实验目的实验原理实验一步骤Step1 开ODL 控制器Step2 VM ifconfig查看地址,电脑登陆页面Step3 Mininet连接ODL(指定协议openflow1.0),查看topo结构Step4 Yang UI下找到...
  • 对于NumberPicker不了解的,请自行移步到android NumberPicker 全面解析 本次Demo总共有四种样式。由于全部贴出本文篇幅较长,所以只贴关于月日时分样式选择器代码。 下面直接看我们的自定义View,上代码: ...
  • Vue 限制input输入 小数点后两位number

    万次阅读 2018-07-24 11:05:13
    3. Vue 限制input输入 小数点后两位number 首先介绍一些input(表单元素)常见的type type 类型说明 text - button - number 过滤非数值类型的值 tel 用于输入电话号码的控件 file - ...
  • 在go 1.14中使用json.Number类型, 在json.Unmarshal时会返回错误json: invalid number literal, trying to unmarshal “\”\"" into Number 解决方法 暂时不要用go 1.14 使用interface{}类型替代json.Number 错误...
  • row_number() 耗时: 2.2秒rownum 耗时:1.3秒 查询第20000页,每页10条。row_number() 耗时: 4.5秒+rownum 耗时:3.8秒+ 网上看到的说,row_number()效率最高看来是没有经过大数据测试的。 本来还寄希望于row_...
  • HDU-2032 Yang Hui triangle

    2019-12-20 16:23:03
    See the article on ...Yang Hui triangle Remember the Yang Hui triangle you learned in middle school? The specific definition is not de...
  • Oracle数字类型number自增的实现代码

    千次阅读 2018-08-02 16:13:17
    创建序列 ? 1 2 3 4 5 6 7 create sequence seq_student start with 6 increment by 1 maxvalue 500 nominvalue nocycle nocache;......
  • 要求随机抽取5名人员作为...row_number() over(partition by A order by B ) 对表中的数据随机排列显示 : newid() 代码: select * from ( select ROW_NUMBER() over(order by newid() )as rn, ...
  • #测试表的内容结构:如下所示: 其中DATEHH字段:代表...现有如下需求:字段类型,从varchar2改变为number, 字段中 ‘。’去除, 2013103少一个0,需要添加,月份可能会少0, 42开头的历史数据不动 SQL&g...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,019
精华内容 5,207
关键字:

numberyang