netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/utils/NetconfTopologySetup.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.netconf.topology.singleton.impl.utils;
  10
  11 import akka.actor.ActorSystem;
  12 import io.netty.util.concurrent.EventExecutor;
  13 import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
  14 import org.opendaylight.controller.config.threadpool.ThreadPool;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  17 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  18 import org.opendaylight.controller.sal.core.api.Broker;
  19 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
  20 import org.opendaylight.netconf.client.NetconfClientDispatcher;
  21 import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice;
  22 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  23 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  24 import scala.concurrent.duration.Duration;
  25
  26 public class NetconfTopologySetup {
  27
  28     private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
  29     private final RpcProviderRegistry rpcProviderRegistry;
  30     private final DataBroker dataBroker;
  31     private final InstanceIdentifier<Node> instanceIdentifier;
  32     private final Node node;
  33     private final BindingAwareBroker bindingAwareBroker;
  34     private final ScheduledThreadPool keepaliveExecutor;
  35     private final ThreadPool processingExecutor;
  36     private final Broker domBroker;
  37     private final ActorSystem actorSystem;
  38     private final EventExecutor eventExecutor;
  39     private final NetconfClientDispatcher netconfClientDispatcher;
  40     private final String topologyId;
  41     private final NetconfDevice.SchemaResourcesDTO schemaResourceDTO;
  42     private final Duration idleTimeout;
  43
  44     private NetconfTopologySetup(final NetconfTopologySetupBuilder builder) {
  45         this.clusterSingletonServiceProvider = builder.getClusterSingletonServiceProvider();
  46         this.rpcProviderRegistry = builder.getRpcProviderRegistry();
  47         this.dataBroker = builder.getDataBroker();
  48         this.instanceIdentifier = builder.getInstanceIdentifier();
  49         this.node = builder.getNode();
  50         this.bindingAwareBroker = builder.getBindingAwareBroker();
  51         this.keepaliveExecutor = builder.getKeepaliveExecutor();
  52         this.processingExecutor = builder.getProcessingExecutor();
  53         this.domBroker = builder.getDomBroker();
  54         this.actorSystem = builder.getActorSystem();
  55         this.eventExecutor = builder.getEventExecutor();
  56         this.netconfClientDispatcher = builder.getNetconfClientDispatcher();
  57         this.topologyId = builder.getTopologyId();
  58         this.schemaResourceDTO = builder.getSchemaResourceDTO();
  59         this.idleTimeout = builder.getIdleTimeout();
  60     }
  61
  62     public ClusterSingletonServiceProvider getClusterSingletonServiceProvider() {
  63         return clusterSingletonServiceProvider;
  64     }
  65
  66     public RpcProviderRegistry getRpcProviderRegistry() {
  67         return rpcProviderRegistry;
  68     }
  69
  70     public DataBroker getDataBroker() {
  71         return dataBroker;
  72     }
  73
  74     public InstanceIdentifier<Node> getInstanceIdentifier() {
  75         return instanceIdentifier;
  76     }
  77
  78     public Node getNode() {
  79         return node;
  80     }
  81
  82     public BindingAwareBroker getBindingAwareBroker() {
  83         return bindingAwareBroker;
  84     }
  85
  86     public ThreadPool getProcessingExecutor() {
  87         return processingExecutor;
  88     }
  89
  90     public ScheduledThreadPool getKeepaliveExecutor() {
  91         return keepaliveExecutor;
  92     }
  93
  94     public Broker getDomBroker() {
  95         return domBroker;
  96     }
  97
  98     public ActorSystem getActorSystem() {
  99         return actorSystem;
 100     }
 101
 102     public EventExecutor getEventExecutor() {
 103         return eventExecutor;
 104     }
 105
 106     public String getTopologyId() {
 107         return topologyId;
 108     }
 109
 110     public NetconfClientDispatcher getNetconfClientDispatcher() {
 111         return netconfClientDispatcher;
 112     }
 113
 114     public NetconfDevice.SchemaResourcesDTO getSchemaResourcesDTO() {
 115         return  schemaResourceDTO;
 116     }
 117
 118     public Duration getIdleTimeout() {
 119         return idleTimeout;
 120     }
 121
 122     public static class NetconfTopologySetupBuilder {
 123
 124         private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
 125         private RpcProviderRegistry rpcProviderRegistry;
 126         private DataBroker dataBroker;
 127         private InstanceIdentifier<Node> instanceIdentifier;
 128         private Node node;
 129         private BindingAwareBroker bindingAwareBroker;
 130         private ScheduledThreadPool keepaliveExecutor;
 131         private ThreadPool processingExecutor;
 132         private Broker domBroker;
 133         private ActorSystem actorSystem;
 134         private EventExecutor eventExecutor;
 135         private String topologyId;
 136         private NetconfClientDispatcher netconfClientDispatcher;
 137         private NetconfDevice.SchemaResourcesDTO schemaResourceDTO;
 138         private Duration idleTimeout;
 139
 140         public NetconfTopologySetupBuilder(){
 141         }
 142
 143         private ClusterSingletonServiceProvider getClusterSingletonServiceProvider() {
 144             return clusterSingletonServiceProvider;
 145         }
 146
 147         public NetconfTopologySetupBuilder setClusterSingletonServiceProvider(
 148                 final ClusterSingletonServiceProvider clusterSingletonServiceProvider) {
 149             this.clusterSingletonServiceProvider = clusterSingletonServiceProvider;
 150             return this;
 151         }
 152
 153         private RpcProviderRegistry getRpcProviderRegistry() {
 154             return rpcProviderRegistry;
 155         }
 156
 157         public NetconfTopologySetupBuilder setRpcProviderRegistry(final RpcProviderRegistry rpcProviderRegistry) {
 158             this.rpcProviderRegistry = rpcProviderRegistry;
 159             return this;
 160         }
 161
 162         private DataBroker getDataBroker() {
 163             return dataBroker;
 164         }
 165
 166         public NetconfTopologySetupBuilder setDataBroker(final DataBroker dataBroker) {
 167             this.dataBroker = dataBroker;
 168             return this;
 169         }
 170
 171         private InstanceIdentifier<Node> getInstanceIdentifier() {
 172             return instanceIdentifier;
 173         }
 174
 175         public NetconfTopologySetupBuilder setInstanceIdentifier(final InstanceIdentifier<Node> instanceIdentifier) {
 176             this.instanceIdentifier = instanceIdentifier;
 177             return this;
 178         }
 179
 180         public Node getNode() {
 181             return node;
 182         }
 183
 184         public NetconfTopologySetupBuilder setNode(final Node node) {
 185             this.node = node;
 186             return this;
 187         }
 188
 189         public NetconfTopologySetup build() {
 190             return new NetconfTopologySetup(this);
 191         }
 192
 193         private BindingAwareBroker getBindingAwareBroker() {
 194             return bindingAwareBroker;
 195         }
 196
 197         public NetconfTopologySetupBuilder setBindingAwareBroker(final BindingAwareBroker bindingAwareBroker) {
 198             this.bindingAwareBroker = bindingAwareBroker;
 199             return this;
 200         }
 201
 202         private ScheduledThreadPool getKeepaliveExecutor() {
 203             return keepaliveExecutor;
 204         }
 205
 206         public NetconfTopologySetupBuilder setKeepaliveExecutor(final ScheduledThreadPool keepaliveExecutor) {
 207             this.keepaliveExecutor = keepaliveExecutor;
 208             return this;
 209         }
 210
 211         private ThreadPool getProcessingExecutor() {
 212             return processingExecutor;
 213         }
 214
 215         public NetconfTopologySetupBuilder setProcessingExecutor(final ThreadPool processingExecutor) {
 216             this.processingExecutor = processingExecutor;
 217             return this;
 218         }
 219
 220         private Broker getDomBroker() {
 221             return domBroker;
 222         }
 223
 224         public NetconfTopologySetupBuilder setDomBroker(final Broker domBroker) {
 225             this.domBroker = domBroker;
 226             return this;
 227         }
 228
 229         private ActorSystem getActorSystem() {
 230             return actorSystem;
 231         }
 232
 233         public NetconfTopologySetupBuilder setActorSystem(final ActorSystem actorSystem) {
 234             this.actorSystem = actorSystem;
 235             return this;
 236         }
 237
 238         private EventExecutor getEventExecutor() {
 239             return eventExecutor;
 240         }
 241
 242         public NetconfTopologySetupBuilder setEventExecutor(final EventExecutor eventExecutor) {
 243             this.eventExecutor = eventExecutor;
 244             return this;
 245         }
 246
 247         private String getTopologyId() {
 248             return topologyId;
 249         }
 250
 251         public NetconfTopologySetupBuilder setTopologyId(final String topologyId) {
 252             this.topologyId = topologyId;
 253             return this;
 254         }
 255
 256         private NetconfClientDispatcher getNetconfClientDispatcher() {
 257             return netconfClientDispatcher;
 258         }
 259
 260         public NetconfTopologySetupBuilder setNetconfClientDispatcher(final NetconfClientDispatcher clientDispatcher) {
 261             this.netconfClientDispatcher = clientDispatcher;
 262             return this;
 263         }
 264
 265         public NetconfTopologySetupBuilder setSchemaResourceDTO(
 266                 final NetconfDevice.SchemaResourcesDTO schemaResourceDTO) {
 267             this.schemaResourceDTO = schemaResourceDTO;
 268             return this;
 269         }
 270
 271         private NetconfDevice.SchemaResourcesDTO getSchemaResourceDTO() {
 272             return schemaResourceDTO;
 273         }
 274
 275         public NetconfTopologySetupBuilder setIdleTimeout(final Duration idleTimeout) {
 276             this.idleTimeout = idleTimeout;
 277             return this;
 278         }
 279
 280         private Duration getIdleTimeout() {
 281             return idleTimeout;
 282         }
 283
 284         public static NetconfTopologySetupBuilder create() {
 285             return new NetconfTopologySetupBuilder();
 286         }
 287     }
 288
 289
 290 }