将NetConf转成NormalizedNode对象及NormalizedNode对象转回NetConf（序列化与反序列化）

最新推荐文章于 2022-05-06 16:17:10 发布
最新推荐文章于 2022-05-06 16:17:10 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： SDN 文章标签： NetConf NormalizedNode java opendaylight yangtools
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kangyucheng/article/details/89211143
版权

背景

我们可以在管理设备的时候可以通过netconf来管理，yangtools给我们提供了一个很好地工具。可以将netconf加载到NormalizedNode对象当中。这样我们就能够通过操控NormalizedNode对象，来操控设备。如下图所示

（yangtools指的是opendaylight中的yangtools,https://github.com/opendaylight）

第一步：建立Maven工程 ，配置pom.xml

我的工程命名是：TestYangTools

配置JDK和maven就不赘述了。

maven文件如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>TestYangTools</groupId>
    <artifactId>TestYangTools</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!--xml转NormalizedNode-->
        <dependency>
            <groupId>org.opendaylight.yangtools</groupId>
            <artifactId>yang-data-codec-xml</artifactId>
            <version>2.0.16</version>
        </dependency>

        <!--读取yang文件-->
        <dependency>
            <groupId>org.opendaylight.yangtools</groupId>
            <artifactId>yang-test-util</artifactId>
            <version>2.0.16</version>
        </dependency>


        <!--json转NormalizedNode-->
        <dependency>
            <groupId>org.opendaylight.yangtools</groupId>
            <artifactId>yang-data-codec-gson</artifactId>
            <version>2.0.16</version>
        </dependency>


        <!--里面日志，如果不导入无法执行-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>


    </dependencies>


</project>

 第二步编写代码

我的工程文件目录如下：

 

Mytest文件代码如下

 我们在代码中实现了NetConf转成NormalizedNode对象及NormalizedNode对象转回NetConf，并输出结果

package com.kangyucheng;

import com.google.common.collect.ImmutableList;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.stream.JsonReader;
import jdk.internal.org.xml.sax.SAXException;

import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonWriterFactory;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.net.URI;
import java.net.URISyntaxException;



public class MyTest {

    private static String loadTextFile(String relativePath) throws IOException, URISyntaxException {
        File file = new File(MyTest.class.getResource(relativePath).toURI());
        FileReader fileReader = new FileReader(file);
        BufferedReader bufReader = new BufferedReader(fileReader);

        String line = null;
        StringBuilder result = new StringBuilder();
        while ((line = bufReader.readLine()) != null) {
            result.append(line);
        }
        bufReader.close();
        return result.toString();
    }

    private static void writeStringToFile(String text, String filePath) {
        try {
            FileOutputStream fos = new FileOutputStream(filePath);
            fos.write(text.getBytes());
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static Document loadDocument(String xmlPath) throws IOException, org.xml.sax.SAXException {
        InputStream resourceAsStream = MyTest.class.getResourceAsStream(xmlPath);
        Document doc = UntrustedXML.newDocumentBuilder().parse(resourceAsStream);
        doc.getDocumentElement().normalize();
        return doc;
    }


    private static String toString(Node xml) {
        try {
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

            StreamResult result = new StreamResult(new StringWriter());
            DOMSource source = new DOMSource(xml);
            transformer.transform(source, result);

            return result.getWriter().toString();
        } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
            throw new RuntimeException("Unable to serialize xml element " + xml, e);
        }
    }

    @Test
    public void jsonToNormalizedNodesTest() throws IOException, URISyntaxException, SAXException {

        //json转NormalizedNode
        SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/baz/");
        NormalizedNodeResult result = new NormalizedNodeResult();
        NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
        JsonParserStream jsonParser = JsonParserStream.create(streamWriter,
                JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext));


        String inputJson = loadTextFile("/baz/baz.json");
        jsonParser.parse(new JsonReader(new StringReader(inputJson)));
        NormalizedNode<?, ?> transformedInput = result.getResult();

        System.out.println("NormalizedNode:"+transformedInput);

        //NormalizedNode转json
        Writer writer = new StringWriter();
        NormalizedNodeStreamWriter jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
                JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), SchemaPath.ROOT, null,
                JsonWriterFactory.createJsonWriter(writer, 2));
        NormalizedNodeWriter nodeWriter = NormalizedNodeWriter.forStreamWriter(jsonStream);
        nodeWriter.write(transformedInput);
        nodeWriter.close();

        String jsonOutput = writer.toString();
        writer.toString();
        JsonParser parser = new JsonParser();
        JsonElement serializedJson = parser.parse(jsonOutput);

        System.out.println("序列化json"+serializedJson.toString());//序列化之后的json
        writeStringToFile(serializedJson.toString(), "newbaz.json");
        System.out.println("原有json"+inputJson);//原有json

    }

    @Test
    public void testXmlToNormalizedNode() throws URISyntaxException, IOException, ParserConfigurationException, SAXException, XMLStreamException, org.xml.sax.SAXException {

        /*
        由xml转NormalizedNode
         */
        QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-namespace"));
        QName PARENT_CONTAINER = QName.create(FOO_MODULE, "parent-container");

        SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/foo/");
        ContainerSchemaNode parentContainerSchema = (ContainerSchemaNode) SchemaContextUtil.findNodeInSchemaContext(schemaContext,
                ImmutableList.of(PARENT_CONTAINER));

        System.out.println("加载yang:"+schemaContext);
        InputStream resourceAsStream = MyTest.class.getResourceAsStream("/foo/foo.xml");

        XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);

        NormalizedNodeResult result = new NormalizedNodeResult();
        NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);

        XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
        xmlParser.parse(reader);

        NormalizedNode<?, ?> transformedInput = result.getResult();

        System.out.println("NormalizedNode:"+transformedInput);

        /*
        由NormalizedNode转xml
         */

//        SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/");
        Document doc = loadDocument("/foo/foo.xml");
        DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
        XMLOutputFactory factory = XMLOutputFactory.newFactory();
        XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);

        NormalizedNodeStreamWriter xmlNormalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(
                xmlStreamWriter, schemaContext);

        NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
                xmlNormalizedNodeStreamWriter);

//        normalizedNodeWriter.write(buildOuterContainerNode());//此处可以通过一个函数构建
        normalizedNodeWriter.write(transformedInput);

        String expectedXml = toString(doc.getDocumentElement());//为了比较
        String serializedXml = toString(domResult.getNode());//序列化之后的
        System.out.println("原有xml："+expectedXml);//为了比较
        writeStringToFile(serializedXml.toString(), "newfoo.xml");
        System.out.println("序列化之后xml："+serializedXml);//序列化之后的


    }
}

两个Test分别是测试json和xml的

baz文件夹：

这里面的文件都来自于opendaylight提供的源码中拷贝出来

baz.json

{
   "baz:baz":{
      "my-container-1":{
         "my-leaf-1":"value1"
      },
      "my-container-2":{
         "inner-container":{
            "my-leaf-2":"value2"
         },
         "my-leaf-3":"value3"
      },
      "my-anyxml-data":{
         "inner-container":{
            "my-leaf-2":"any-xml-leaf-2-value"
         },
         "my-leaf-3":"any-xml-leaf-3-value"
      }
   }
}

baz.yang

module baz {
    namespace "baz";
    prefix baz;

    import yang-ext { prefix ext; revision-date 2013-07-09; }

    container baz {
        container my-container-1 {
            leaf my-leaf-1 {
                type string;
            }
        }

        container my-container-2 {
            container inner-container {
                leaf my-leaf-2 {
                    type string;
                }
            }
            leaf my-leaf-3 {
                type string;
            }
        }

        anyxml my-anyxml-data {
            ext:anyxml-schema-location "/baz/my-container-2";
        }
    }
}

yang-ext.yang

module yang-ext {
    yang-version 1;
    namespace "urn:opendaylight:yang:extension:yang-ext";
    prefix "ext";

    contact "Anton Tkacik <ttkacik@cisco.com>";

    description
        "Copyright (c) 2013 Cisco Systems, Inc. and others. All rights
        reserved. This program and the accompanying materials are made
        available under the terms of the Eclipse Public License v1.0 which
        accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html";

    revision "2013-07-09" {
        description "";
    }

    // Augmentation name

    extension "augment-identifier" {
        description
                "YANG language extension which assigns an identifier to augmentation.
                Augment identifier is used to identify specific augment statement
                by name. The identifier syntax is defined formally defined by
                the rule 'identifier' in Section 12 of RFC 6020. All augment identifiers
                defined in a namespace MUST be unique. The namespace of augment
                identifiers is shared by module and its submodules.";

        /*
                Discussion:
                This extension allows for ease of development / debug
                of YANG modules and it is suitable for code generation,
                where each augment statement is nicely identified by
                unique name instead of combination of augment target
                and when condition.
            */
        argument "identifier";
    }

    // Context-aware RPCs

    grouping rpc-context-ref {
        description
                "A reference to RPC context.";
        leaf context-instance {
            type instance-identifier;
            description "Pointer to the context. ";
        }
    }

    extension "rpc-context-instance" {
        description
                "YANG language extension which defines enclosing (parent) schema
                node as referencable context for RPCs. The argument is identity
                which is used to identify RPC context type.";

        argument "context-type";
    }

    extension "context-reference" {
        argument "context-type";
    }

    extension "context-instance" {
        argument "context-type";
    }

    extension "instance-target" {
        argument "path";
    }

    extension "anyxml-schema-location" {
        argument "target-node";
    }
}

foo文件夹

这里面的文件都来自于opendaylight提供的源码中拷贝出来

foo.xml

<?xml version="1.0" encoding="UTF-8"?>

<parent-container xmlns="foo-namespace">
    <leaf-container>
        <union-identityref-leaf xmlns:prefix="foo-namespace">prefix:ident-one</union-identityref-leaf>
        <int32-leaf>1500</int32-leaf>
        <decimal64-leaf>150.45</decimal64-leaf>
        <string-leaf>hello world</string-leaf>
        <leafref-leaf>hello world</leafref-leaf>
        <empty-leaf/>
        <boolean-leaf>true</boolean-leaf>
        <enum-leaf>five</enum-leaf>
    </leaf-container>
    <anyxml-container>
        <my-anyxml><my-element><my-sub-element>&lt; &amp; sub-element value</my-sub-element></my-element></my-anyxml>
    </anyxml-container>
</parent-container>

foo.yang

module foo {
    namespace "foo-namespace";
    prefix "f";

    identity ident-base;
    identity ident-one {
        base ident-base;
    }

    typedef union-type {
        type union {
            type uint8;
            type identityref {
                base ident-base;
            }
        }
    }

    container parent-container {

        container leaf-container {

            leaf union-identityref-leaf {
                type union-type;
            }

            leaf int32-leaf {
                type int32;
            }

            leaf decimal64-leaf {
                type decimal64 {
                    fraction-digits 2;
                }
            }

            leaf string-leaf {
                type string;
            }

            leaf leafref-leaf {
                type leafref {
                    path "../string-leaf";
                }
            }

            leaf empty-leaf {
                type empty;
            }

            leaf boolean-leaf {
                type boolean;
            }

            leaf enum-leaf {
                type enumeration {
                    enum zero;
                    enum one;
                    enum five {
                        value 5;
                    }
                }
            }
        }

        container anyxml-container {
            anyxml my-anyxml;
        }
    }


}

第三步运行

 

 

可以发现生成的文件，可以手动对比一下原来的json和xml文件。

 

 

康雨城
关注
专栏目录
云网融合与算力网络系列文章
烟云的计算
02-28 7307
目录 文章目录目录OvSDPDKVPPNeutron OvS 《OpenFlow Switch 1.3 规范》 《OpenvSwitch 架构解析与功能实践》 《基于 Open vSwitch 的 OpenFlow 实践》 DPDK 《用户态网络协议栈还是内核协议栈？》 《DPDK — 数据平面开发技术》 《DPDK — 数据平台优化技术》 《DPDK — 架构解析》 《DPDK — 安装部署》 《DPDK — PMD，DPDK 的核心优化》 《DPDK — IGB_UIO，与 UIO Framework
第07课：RNN 在序列问题中的应用——文本分类
万宫玺的专栏
09-22 554
本节课我们介绍另一种常用的神经网络结果——循环神经网络（Recurrent Neural Network，RNN）。需要注意的是，RNN 可以是两种神经网络的缩写，一种是本次课程讨论的 Recurrrent Neural Network，另一种则是 Recursive Neural Network，也称递归神经网络。前者是时间递归的神经网络，而后者是结构递归。在下文中，如果不特别说明，RNN 都代...
netconf-node:通过节点连接到 netconf 的库
06-13
网络配置节点 通过节点连接到 netconf 的库 根据 Apache License 2.0 获得许可
Json格式的netconf转成NormalizedNode
康雨城
05-28 830
之前发过一篇文章 将NetConf转成NormalizedNode对象及NormalizedNode对象转回NetConf（序列化与反序列化） 该文章的不足之处在于 无论json还是xml文件都是完整的，但是实际的情况可能是不完整的。 想要将部分的json转成NormalizedNode
netconf4j-develop.zip
06-23
netconfig java 的样例代码，解压后导入maven项目，运行即可，数据源为xml模拟数据。
config4j
06-26
其实这个东西很简单，甚至没有用到工厂，也没有用接口，4个文件搞定。一个XML工具类，一个系统工具类，一个结点对象，一个BUILDER，如此而已，我就不信这个小东西对于经常读取XML配置文件的人来说不能提供方便？大家有心情试试看，提供源码和DEMO！目前是1.0版本，本人将不定期更新！参考了XPATH方式，可以直接用路径的方式读取文件结点内容，如下：public static void main(String[] args){ ConfigBuilder cb = new ConfigBuilder("config/db-conf
Java NetConf 使用
Java的一只小实习生的博客
05-06 2636
1. 参考资料 工具包GIT地址 : https://github.com/Juniper/netconf-java 使用教程 : https://www.juniper.net/documentation/cn/zh/software/junos/netconf-java-toolkit/topics/task/netconf-java-toolkit-program-creating-and-executing.html 2. 下载&编译工具包 # 1. 下载git地址中的工具包到本地
juniper-grafana:使用 Grafana、InfluxDB、PyEZ 和 GPB 可视化瞻博网络设备遥测
07-23
用于反序列化由瞻博网络 QFX 交换机流式传输的分析记录的 。 用于生成遥测数据的虚拟防火墙（作为示例）。 下面的所有示例和脚本都是为 64 位 Ubuntu 15.04 编写的。 这是一个有趣的个人项目。 它不以任何方式、...
第39章 ETH—Lwip以太网通信—零死角玩转STM32-F429系列
热门推荐
flyleaf91的专栏
08-26 3万+
第39章     ETH—Lwip以太网通信 全套200集视频教程和1000页PDF教程请到秉火论坛下载：www.firebbs.cn 野火视频教程优酷观看网址：http://i.youku.com/firege       互联网技术对人类社会的影响不言而喻。当今大部分电子设备都能以不同的方式接入互联网(Internet)，在家庭中PC常见的互联网接入方式是使用路由器(Route
NETCONF协议基础中文讲解.pdf
09-24
随着SDN的大热，一个诞生了十年之久的协议焕发了第二春，它就是NETCONF协议。如果你在两年前去搜索NETCONF协议，基本得到的信息都是“这个协议是一个网管协议，主要目的是弥补SNMP协议的不足，希望可以取代SNMP协议”。SNMP有哪些不足，而NETCONF是否真的能够弥补，这都不是重点，重点是NETCONF诞生至今SNMP依旧活的好好的。所以如果我们还是把NETCONF当做一个网管协议的话，估计它会在冷板凳上一直坐下去，而如果我们换一个角度去看待NETCONF协议，你会发现也许它是最适合SDN的一个协议。
java通过netconf协议 操作华为、h3c交换机可实现增删静态路由条目等功能
03-23
已调试通过，支持华为、华三等各种主流设备。下载后无需修改。内有Test.main 在main里把配置改成自己的，直接运行就ok。
17-网络管理和监控配置指导-NETCONF配置
05-04
很详细的讲解说明，网络管理和监控配置指导-NETCONF配置
netconf学习
laputa73的专栏
08-18 1万+
近来用户要求研究下一代的网管配置协议netconf 要和相关设备接口 网上搜了一下相关的开源产品 还真是不容易 juniper提供了一套perl的模块，看起来很合适，可是居然要有账号才可以下载。变封闭了。。。 网上的开源方案主要有2个： 一个是ensuite的yenc
NETCONF YANG语言文件语法格式
RToax
02-17 2769
NETCONF(Network Configuration Protocol)，该协议的配置功能非常强大，同时兼顾监控和故障管理，安全验证和访问控制，得到业界的一致认可，被广泛用来配置网络 NETCONF协议分为传输层、RPC层、操作层和内容层。其中，内容层是唯一没有标准化的层，于是一种新的建模语言YANG产生了，它的目标是对NETCONF数据模型、操作进行建模，覆盖NETCONF协议的操作层和...
netconf ssh
ggaofengg的专栏
04-30 2987
NETCONF协议详解 https://blog.csdn.net/anzheangel/article/details/78885880 Hi Viraj, our software consists of 2 main packages: libnetconf is a library that is meant for building NETCONF servers and cli...
ODL netconf挂载点操作设备
sunquan291的专栏
12-11 4881
学习Netconf协议中，在与设备交互中，存在挂载点概念，操作该挂载点等同于操作该设备(实际是通过下发设备支持报文)。 下面分析下这里的实现机制： 为实现设备挂载，首先需要设备，使用ODL提供的设备模拟器，启动： java -jar netconf-testtool-1.0.5-2.00.10R1B05-executable.jar 如果启动正常，则最后打印： 该模拟工具
网络配置协议NetConf概述
成长的足迹
01-22 8726
NetConf  (Network Configuration)是IETF发布的网络管理协议，用于在网络范围内配置各种网络设备。 NetConf的规范文档RFC 4741已经终止，被RFC 6241替代。 1.网络设备在出厂时都有一个初始配置，在实际的应用中，通过NetConf修改其初始配置为需要的运行配置状态。 对网络设备的配置操作可以分类如下： 安装配置操作配置删除配置
ubuntu16.04安装OVS(Open vSwitch)
康雨城
04-07 5961
OVS是一个具备生产能力、在开源Apache许可下的多层虚拟交换机，OVS能够在VM环境中很好的实现虚拟交换机的功能。 本文介绍了如何在ubuntu16.04安装OVS。
NETCONF协议中子树过滤到XPath转换的研究与实现
"这篇论文研究了子树过滤到XPath转换的实现与分析，主要关注于NETCONF协议在网络管理中的应用。NETCONF是由IETF工作小组提出的新型网络管理协议，它利用XML来定义配置数据和协议消息，并推荐了一种新的过滤机制——...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

康雨城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值