Opendaylight课堂之深度剖析toaster（二）

最新推荐文章于 2022-05-16 18:51:46 发布

xxb249

最新推荐文章于 2022-05-16 18:51:46 发布

阅读量1.2k

点赞数 1

分类专栏： opendaylight专题

本文链接：https://blog.csdn.net/xxb249/article/details/49953051

版权

opendaylight专题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

接上一篇内容

一、实现服务--mytoaster-provider（核心内容）

1、在目录demo2中增加mytoaster-provider目录以及子目录、文件：

mytoaster-provider

├── pom.xml

└── src

└── main

├── java

└── resources

2、Pom文件主要修改内容(参考sample中)：

  <groupId>org.opendaylight.controller.demo2</groupId>
  <artifactId>mytoaster-provider</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>bundle</packaging>
 
  <dependencies>
   <dependency><!-- mytoaster-provide需要依赖mytoaster定义的服务 -->
      <groupId>${project.groupId}</groupId>
      <artifactId>mytoaster</artifactId>
      <version>${project.version}</version>
   </dependency>
   ....          
  </dependencies>

3、增加源码文件，org/opendaylight/controller/demo2/mytoaster/provider/MyOpenDaylightToaster.java

在开始写代码前介绍一下在java1.7新引入AutoCloseable接口。在java1.7之前释放资源，比如关闭文件句柄，一般写道try-catch中的finally中，但如果在finally中出现异常，那么这个资源就无法回收了。因此在java1.7中增加了AutoCloseable接口，以解决这种问题，用于在最后回收资源，感觉像C++中的析构函数。（但是AutoCloseable出现异常呢？等待高手指点）

我们知道对于OSGi框架最小调度单元是bundle，因此我们先现实mytoaster-provider这个bundle，使其能够在odl中跑起来。为了实现这个功能，需要实现以下三步骤：

1）AutoCloseable接口。

2）注册bundle。在碳版本中，bundle的注册是通过blueprint方式，具体blueprint使用可以参考如下两个地址：IBM开发者社区和Opendaylight官方社区。

3）Feature定义。

具体代码如下：

public class MyOpendaylightToaster implements MytoasterService,AutoCloseable {
    private static final InstanceIdentifier<Mytoaster> TOASTER_IID = InstanceIdentifier.builder(Mytoaster.class).build();
    private static final MyDisplayString TOASTER_MANUFACTURER = new MyDisplayString("Opendaylight");
    private static final MyDisplayString TOASTER_MODEL_NUMBER = new MyDisplayString("Model 1 - Binding Aware");
    private DataBroker dataBroker;

    public void setDataBroker(DataBroker dataBroker) {
        this.dataBroker = dataBroker;
    }
    public MyOpendaylightToaster() {
    }
    /**
     * 初始化Toaster 创建一个toaster保存到datastore中
     */
    public void init() {
        setToasterStatusIdle(null);
    }

    /**
     * 关闭服务 回调函数
     * @throws Exception
     */
    public void close() throws Exception {
        if (dataBroker != null) {
            //将toaster从datastore中删除
            WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
            tx.delete(LogicalDatastoreType.OPERATIONAL, TOASTER_IID);
            Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
                @Override
                public void onSuccess(@Nullable Void aVoid) {
                    System.out.println("Delete MyToaster From Datastore Success.");
                }
                @Override
                public void onFailure(Throwable throwable) {
                    System.out.println("Delete MyToaster From Datastore Failed.");
                }
            });
        }
    }

    /**
     * 创建一个Mytoaster服务
     * @param defaultStatus -- 默认状态 idle
     * @return 返回一个Mytoaster实例
     */
    private Mytoaster createToaster(ToasterStatus defaultStatus) {
        MytoasterBuilder builder = new MytoasterBuilder();
        builder.setToasterManufacturer(TOASTER_MANUFACTURER);
        builder.setToasterModelNumber(TOASTER_MODEL_NUMBER);
        builder.setToasterStatus(defaultStatus);
        return builder.build();
    }
    /**
     * 创建一个Toaster并且设置成IDLE态
     * @param resultCallback -- 回调函数
     */
    private void setToasterStatusIdle(final Function<Boolean, Void> resultCallback) {
        //调用datastore接口 创建一个可写事务 
        //将新创建的Toaster保存到dataStore中
        WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
        tx.put(LogicalDatastoreType.OPERATIONAL, TOASTER_IID, createToaster(ToasterStatus.Idle));
        //提交事务 一般放到一个FUTURE中,如果设置了回调函数 则将设置的结果通过回调函数返回
        Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
            @Override
            public void onSuccess(@Nullable Void result) {
                notifyCallback(true);
            }
            @Override
            public void onFailure(Throwable throwable) {
                notifyCallback(false);
            }
            private void notifyCallback(Boolean result) {
                if (resultCallback != null) {
                    resultCallback.apply(result);
                }
            }
        });
    }

注册bundle，在resources目录中创建org/opendaylight/blueprint/mytoaster-provider.xml,具体文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 此处的odl是 opendaylight对blueprint的扩展 扩展了一些自己特有的 具体内容可以参考推荐的两个网址 -->
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
           odl:use-default-for-reference-types="true">
    <!-- 引入dataBroker服务 这样才能操作datastroe -->
    <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
    <!-- 通过bean创建一个MyOpendaylightToaster实例并注册到mdsal中 -->
    <bean id="mytoaster" class="org.opendaylight.controller.demo2.mytoaster.provider.MyOpendaylightToaster"
            init-method="init" destroy-method="close">
        <property name="dataBroker" ref="dataBroker"/>
    </bean>
</blueprint>

经过上面两步骤，就可以完成了bundle基本功能了，比之前的配置子系统要简单很多！！进入mytoaster-provider，进行编译，编译过程中应该没有任何问题，接下来需要设置feature。

设置feature需要做一下修改：

1） Feature定义是在目录controller/features,我们的mytoaster是定义在mdsal中，因此进入controller/features/mdsal增加我们的feature。修改mdsal目录中pom文件，增加<module>odl-mytoaster</module>

2）由于碳版本中karaf升级到4.0版本(碳版本是过渡版本)，feature定义方式存在两种方式。在karaf4下面需要将各个feature独立定义在以俄国目录中，例如是odl-toaster目录。碳之前版本是在mdsal/feature/src/main/features.xml文件中定义。由于对karaf4.0不是很了解，这里只介绍旧方式，即在features.xml文件中定义。增加features定义:

在mdsal/features-mdsal/pom.xml文件中增加依赖：

<!-- mytoaster -->
<dependency>
  <groupId>org.opendaylight.controller.demo2</groupId>
  <artifactId>mytoaster</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency>
  <groupId>org.opendaylight.controller.demo2</groupId>
  <artifactId>mytoaster-provider</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</dependency>

在mdsal/features-mdsal/src/main/features/features.xml文件中增加feature定义：

<feature name='odl-mytoaster' version='${project.version}' description="OpenDaylight :: MyToaster">
    <feature version='${yangtools.version}'>odl-yangtools-common</feature>
    <feature version='${mdsal.version}'>odl-mdsal-binding-runtime</feature>
    <feature version='${project.version}'>odl-mdsal-broker</feature>
    <bundle>mvn:org.opendaylight.controller.demo2/mytoaster/{{VERSION}}</bundle>    <bundle>mvn:org.opendaylight.controller.demo2/mytoaster-provider/{{VERSION}}</bundle>
</feature>

以上内容就是feature的定义，在mdsal目录中进行编译应该可以正常编译出来。虽然能编译出来但是还不能运行，因为从github下载controller代码，并没有依赖上restconf，因此需要作如下修改：

3）修改controller/karaf/opendaylight-karaf目录中的pom文件，增加如下内容：

<dependency>
  <groupId>org.opendaylight.netconf</groupId>
  <artifactId>features-netconf</artifactId>
  <version>1.2.2-SNAPSHOT</version>
  <classifier>features</classifier>
  <type>xml</type>
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>org.opendaylight.netconf</groupId>
  <artifactId>features-netconf-connector</artifactId>
  <version>1.2.2-SNAPSHOT</version>
  <classifier>features</classifier>
  <type>xml</type>
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>org.opendaylight.netconf</groupId>
  <artifactId>features-restconf</artifactId>
  <version>1.5.2-SNAPSHOT</version>
  <classifier>features</classifier>
  <type>xml</type>
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>org.opendaylight.netconf</groupId>
  <artifactId>features-yanglib</artifactId>
  <version>1.2.2-SNAPSHOT</version>
  <classifier>features</classifier>
  <type>xml</type>
  <scope>runtime</scope>
</dependency>

经过以上内容修改，把修改的模块重新编译一次，应该就能运行起来了。至此修改编译的目录以及顺序如下：

demo2/mytoaster，demo2/mytoaster-provider，features/mdsal，karaf/opendaylight-karaf。

编译完成之后，启动karaf，如下：

opendaylight-user@root>
opendaylight-user@root>
opendaylight-user@root>
opendaylight-user@root>feature:install odl-restconf-all
opendaylight-user@root>feature:install odl-mytoaster
opendaylight-user@root>bundle:list | grep toaster
284 | Active   |  80 | 0.0.1.SNAPSHOT                      | mytoaster                                                          
285 | Active   |  80 | 0.0.1.SNAPSHOT                      | mytoaster-provider                                                 
opendaylight-user@root>

我们是postman获取一下toaster基本信息，如何返回和下图一致，则说明正确：

Url：http://localhost:8181/restconf/operational/mytoaster:mytoaster，用户名和密码都是admin

至此服务的注册已经完成，接下来就是要是服务。我们都知道odl采用rpc的方式提供服务，因此我们要把yang模型中定义的所有rpc都要实现。在MyOpendaylightToaster实现MytoasterService接口，并且添加rpc的实现如下（只显示修改内容）：

public class MyOpendaylightToaster implements MytoasterService,AutoCloseable {
    ...
    private static final int MAX_TRY_COUNT = 3;//发生异常时最大尝试次数
    private final ExecutorService executor;
    private final AtomicReference<Future<?>> currentToastTask = new AtomicReference<>();
    ..
    public MyOpendaylightToaster() {
        //只有一个线程 因为一个面包机只能烤完一个才能烤下一个
        executor = Executors.newFixedThreadPool(1);
}
    public void close() throws Exception {
        executor.shutdown();//关闭线程池否则服务无法正常退出
    ...
}
@Override
    public Future<RpcResult<MakeToastOutput>> makeToast(MakeToastInput input) {
        final SettableFuture<RpcResult<MakeToastOutput>> futureResult = SettableFuture.create();
    //检查toaster状态并且制作面包
        checkStatusAndMakeToast(input, MAX_TRY_COUNT, futureResult);
        return futureResult;
    }
    @Override
    public Future<RpcResult<Void>> cancelToast() {
        Future<?> current = currentToastTask.getAndSet(null);
        if (current != null) {
            current.cancel(true);
        }
        // Always return success from the cancel toast call
        return Futures.immediateFuture(RpcResultBuilder.<Void> success().build());
    }
private void checkStatusAndMakeToast(final MakeToastInput input, final int tries,
                                        final SettableFuture<RpcResult<MakeToastOutput>> futureResult) {
    //在系统启动的时候 创建了一个toaster实例并保存在datastore中 我们要先判断这个toaster的状态：
    //Idle状态：继续后续流程 制作面包
    //Work状态：直接返回 提示用户正忙，稍后尝试
    ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
    //此处的Optional导入的包是com.google.common.base.Optional;
    ListenableFuture<Optional<Mytoaster>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL, TOASTER_IID);
    //获取datastore中Toaster的状态
    final ListenableFuture<Void> commitFuture = Futures.transform(readFuture,
            (AsyncFunction<Optional<Mytoaster>, Void>) mytoasterOptional -> {
                ToasterStatus status = ToasterStatus.Idle;
                if (mytoasterOptional.isPresent()) {
                    status = mytoasterOptional.get().getToasterStatus();
                }
                if (status == ToasterStatus.Idle) {
                    tx.put(LogicalDatastoreType.OPERATIONAL, TOASTER_IID,
                            createToaster(ToasterStatus.Work));
                    return tx.submit();
                } else {
                    return Futures.immediateFailedFuture(new TransactionCommitFailedException(
                            "", RpcResultBuilder.newError(RpcError.ErrorType.APPLICATION, "Error", "" +
                            "Read Data Is Error.")
                    ));
                }
            });
    //异步等待结果
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(@Nullable Void aVoid) {
            //表示可以制作面包  现实生活中烤面包是需要一定时间的 而且烤成功后会提醒 所以就餐人员可以
            //作其他事情，不必一直等在面包机钱买年  因此我们把烤面包过程交给一个线程 然后立即响应成功
            currentToastTask.set(executor.submit(new MakeToastTask(input)));
            futureResult.set(RpcResultBuilder.success(makeToastOutput("Please Wait A Moment"))
                    .build());
        }

        @Override
        public void onFailure(Throwable ex) {//表示不能制作面包
            if (ex instanceof OptimisticLockFailedException) {
                //如果是加锁失败则进行尝试
                if (tries - 1 > 0) {
                    checkStatusAndMakeToast(input, tries - 1, futureResult);
                } else {
                    futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withResult(makeToastOutput("couldn't Make Toaster!"))
                            .build());
                }
            } else if (ex instanceof TransactionCommitFailedException) {
                futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withResult(makeToastOutput("couldn't Make Toaster!"))
                        .build());
            } else {
                futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withResult(makeToastOutput("couldn't Make Toaster!"))
                        .build());
            }
        }
    });
}
//内部类 实现callable接口 供线程池使用
    private class MakeToastTask implements Callable<Void> {
        final MakeToastInput toastRequest;
        public MakeToastTask(final MakeToastInput toastRequest) {
            this.toastRequest = toastRequest;
        }
        @Override
        public Void call() throws Exception {
            try {
                // 睡眠15秒 表示制作面包
                Thread.sleep(15);
                System.out.println("Break is out!!Please take it");
                //通知烤面包成功 -- notification 后面实现
            } catch (InterruptedException e) {
                System.out.println("Interrupted while making the toast");
                //通知烤面包失败 -- notification
            } finally {
                //制作完面包 要把toaster状态改成idle状态 以便其他人可以继续烤面包
                setToasterStatusIdle(result -> {
                        currentToastTask.set(null);
                        return null;
                    });
            }
            return null;
        }
    }
}

到目前为止，rpc的主要服务均以实现，但是还存在一个问题，我们的rpc已经实现了，但是如何让mdsal知道这个rpc存在呢？答案是：通过blueprint进行注册。

只需要在mytoaster-provider.xml文件中增加: <odl:rpc-implementation ref="mytoaster"/>。

接下来我们来验证结果：

Url：http://localhost:8080/restconf/operations/mytoaster:make-toast