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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23
  24 public class NetconfTopologySetup {
  25
  26     private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
  27     private final RpcProviderRegistry rpcProviderRegistry;
  28     private final DataBroker dataBroker;
  29     private final InstanceIdentifier<Node> instanceIdentifier;
  30     private final Node node;
  31     private final BindingAwareBroker bindingAwareBroker;
  32     private final ScheduledThreadPool keepaliveExecutor;
  33     private final ThreadPool processingExecutor;
  34     private final Broker domBroker;
  35     private final ActorSystem actorSystem;
  36     private final EventExecutor eventExecutor;
  37     private final NetconfClientDispatcher netconfClientDispatcher;
  38     private final String topologyId;
  39     private NetconfTopologySetup(final NetconfTopologySetupBuilder builder) {
  40         this.clusterSingletonServiceProvider = builder.getClusterSingletonServiceProvider();
  41         this.rpcProviderRegistry = builder.getRpcProviderRegistry();
  42         this.dataBroker = builder.getDataBroker();
  43         this.instanceIdentifier = builder.getInstanceIdentifier();
  44         this.node = builder.getNode();
  45         this.bindingAwareBroker = builder.getBindingAwareBroker();
  46         this.keepaliveExecutor = builder.getKeepaliveExecutor();
  47         this.processingExecutor = builder.getProcessingExecutor();
  48         this.domBroker = builder.getDomBroker();
  49         this.actorSystem = builder.getActorSystem();
  50         this.eventExecutor = builder.getEventExecutor();
  51         this.netconfClientDispatcher = builder.getNetconfClientDispatcher();
  52         this.topologyId = builder.getTopologyId();
  53     }
  54
  55     public ClusterSingletonServiceProvider getClusterSingletonServiceProvider() {
  56         return clusterSingletonServiceProvider;
  57     }
  58
  59     public RpcProviderRegistry getRpcProviderRegistry() {
  60         return rpcProviderRegistry;
  61     }
  62
  63     public DataBroker getDataBroker() {
  64         return dataBroker;
  65     }
  66
  67     public InstanceIdentifier<Node> getInstanceIdentifier() {
  68         return instanceIdentifier;
  69     }
  70
  71     public Node getNode() {
  72         return node;
  73     }
  74
  75     public BindingAwareBroker getBindingAwareBroker() {
  76         return bindingAwareBroker;
  77     }
  78
  79     public ThreadPool getProcessingExecutor() {
  80         return processingExecutor;
  81     }
  82
  83     public ScheduledThreadPool getKeepaliveExecutor() {
  84         return keepaliveExecutor;
  85     }
  86
  87     public Broker getDomBroker() {
  88         return domBroker;
  89     }
  90
  91     public ActorSystem getActorSystem() {
  92         return actorSystem;
  93     }
  94
  95     public EventExecutor getEventExecutor() {
  96         return eventExecutor;
  97     }
  98
  99     public String getTopologyId() {
 100         return topologyId;
 101     }
 102
 103     public NetconfClientDispatcher getNetconfClientDispatcher() {
 104         return netconfClientDispatcher;
 105     }
 106
 107     public static class NetconfTopologySetupBuilder {
 108
 109         private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
 110         private RpcProviderRegistry rpcProviderRegistry;
 111         private DataBroker dataBroker;
 112         private InstanceIdentifier<Node> instanceIdentifier;
 113         private Node node;
 114         private BindingAwareBroker bindingAwareBroker;
 115         private ScheduledThreadPool keepaliveExecutor;
 116         private ThreadPool processingExecutor;
 117         private Broker domBroker;
 118         private ActorSystem actorSystem;
 119         private EventExecutor eventExecutor;
 120         private String topologyId;
 121         private NetconfClientDispatcher netconfClientDispatcher;
 122
 123         public NetconfTopologySetupBuilder(){
 124         }
 125
 126         private ClusterSingletonServiceProvider getClusterSingletonServiceProvider() {
 127             return clusterSingletonServiceProvider;
 128         }
 129
 130         public NetconfTopologySetupBuilder setClusterSingletonServiceProvider(
 131                 final ClusterSingletonServiceProvider clusterSingletonServiceProvider) {
 132             this.clusterSingletonServiceProvider = clusterSingletonServiceProvider;
 133             return this;
 134         }
 135
 136         private RpcProviderRegistry getRpcProviderRegistry() {
 137             return rpcProviderRegistry;
 138         }
 139
 140         public NetconfTopologySetupBuilder setRpcProviderRegistry(final RpcProviderRegistry rpcProviderRegistry) {
 141             this.rpcProviderRegistry = rpcProviderRegistry;
 142             return this;
 143         }
 144
 145         private DataBroker getDataBroker() {
 146             return dataBroker;
 147         }
 148
 149         public NetconfTopologySetupBuilder setDataBroker(final DataBroker dataBroker) {
 150             this.dataBroker = dataBroker;
 151             return this;
 152         }
 153
 154         private InstanceIdentifier<Node> getInstanceIdentifier() {
 155             return instanceIdentifier;
 156         }
 157
 158         public NetconfTopologySetupBuilder setInstanceIdentifier(final InstanceIdentifier<Node> instanceIdentifier) {
 159             this.instanceIdentifier = instanceIdentifier;
 160             return this;
 161         }
 162
 163         public Node getNode() {
 164             return node;
 165         }
 166
 167         public NetconfTopologySetupBuilder setNode(final Node node) {
 168             this.node = node;
 169             return this;
 170         }
 171
 172         public NetconfTopologySetup build() {
 173             return new NetconfTopologySetup(this);
 174         }
 175
 176         private BindingAwareBroker getBindingAwareBroker() {
 177             return bindingAwareBroker;
 178         }
 179
 180         public NetconfTopologySetupBuilder setBindingAwareBroker(BindingAwareBroker bindingAwareBroker) {
 181             this.bindingAwareBroker = bindingAwareBroker;
 182             return this;
 183         }
 184
 185         private ScheduledThreadPool getKeepaliveExecutor() {
 186             return keepaliveExecutor;
 187         }
 188
 189         public NetconfTopologySetupBuilder setKeepaliveExecutor(ScheduledThreadPool keepaliveExecutor) {
 190             this.keepaliveExecutor = keepaliveExecutor;
 191             return this;
 192         }
 193
 194         private ThreadPool getProcessingExecutor() {
 195             return processingExecutor;
 196         }
 197
 198         public NetconfTopologySetupBuilder setProcessingExecutor(ThreadPool processingExecutor) {
 199             this.processingExecutor = processingExecutor;
 200             return this;
 201         }
 202
 203         private Broker getDomBroker() {
 204             return domBroker;
 205         }
 206
 207         public NetconfTopologySetupBuilder setDomBroker(Broker domBroker) {
 208             this.domBroker = domBroker;
 209             return this;
 210         }
 211
 212         private ActorSystem getActorSystem() {
 213             return actorSystem;
 214         }
 215
 216         public NetconfTopologySetupBuilder setActorSystem(ActorSystem actorSystem) {
 217             this.actorSystem = actorSystem;
 218             return this;
 219         }
 220
 221         private EventExecutor getEventExecutor() {
 222             return eventExecutor;
 223         }
 224
 225         public NetconfTopologySetupBuilder setEventExecutor(EventExecutor eventExecutor) {
 226             this.eventExecutor = eventExecutor;
 227             return this;
 228         }
 229
 230         private String getTopologyId() {
 231             return topologyId;
 232         }
 233
 234         public NetconfTopologySetupBuilder setTopologyId(String topologyId) {
 235             this.topologyId = topologyId;
 236             return this;
 237         }
 238
 239         private NetconfClientDispatcher getNetconfClientDispatcher() {
 240             return netconfClientDispatcher;
 241         }
 242
 243         public NetconfTopologySetupBuilder setNetconfClientDispatcher(NetconfClientDispatcher clientDispatcher) {
 244             this.netconfClientDispatcher = clientDispatcher;
 245             return this;
 246         }
 247
 248         public static NetconfTopologySetupBuilder create() {
 249             return new NetconfTopologySetupBuilder();
 250         }
 251     }
 252
 253
 254 }