2 * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.controller.clustering.it.provider;
11 import com.google.common.util.concurrent.Futures;
12 import java.util.HashMap;
14 import java.util.concurrent.Future;
15 import org.opendaylight.controller.clustering.it.provider.impl.FlappingSingletonService;
16 import org.opendaylight.controller.clustering.it.provider.impl.GetConstantService;
17 import org.opendaylight.controller.clustering.it.provider.impl.RoutedGetConstantService;
18 import org.opendaylight.controller.clustering.it.provider.impl.SingletonGetConstantService;
19 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
20 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodecFactory;
21 import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationRegistration;
22 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
23 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
24 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
25 import org.opendaylight.controller.sal.core.api.model.SchemaService;
26 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
27 import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
28 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
29 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
30 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.AddShardReplicaInput;
31 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.BecomeModuleLeaderInput;
32 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.BecomePrefixLeaderInput;
33 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.IsClientAbortedOutput;
34 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.OdlMdsalLowlevelControlService;
35 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.ProduceTransactionsInput;
36 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.PublishNotificationsInput;
37 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.RegisterBoundConstantInput;
38 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.RegisterConstantInput;
39 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.RegisterDefaultConstantInput;
40 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.RegisterSingletonConstantInput;
41 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.RemoveShardReplicaInput;
42 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.SubscribeYnlInput;
43 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnregisterBoundConstantInput;
44 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnregisterFlappingSingletonOutput;
45 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnregisterFlappingSingletonOutputBuilder;
46 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnsubscribeDdtlOutput;
47 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnsubscribeDtclOutput;
48 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnsubscribeYnlInput;
49 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.UnsubscribeYnlOutput;
50 import org.opendaylight.yang.gen.v1.tag.opendaylight.org._2017.controller.yang.lowlevel.control.rev170215.WriteTransactionsInput;
51 import org.opendaylight.yangtools.concepts.ListenerRegistration;
52 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
53 import org.opendaylight.yangtools.yang.common.RpcError;
54 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
55 import org.opendaylight.yangtools.yang.common.RpcResult;
56 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
57 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
58 import org.slf4j.Logger;
59 import org.slf4j.LoggerFactory;
61 public class MdsalLowLevelTestProvider implements OdlMdsalLowlevelControlService {
63 private static final Logger LOG = LoggerFactory.getLogger(MdsalLowLevelTestProvider.class);
65 private final RpcProviderRegistry rpcRegistry;
66 private final BindingAwareBroker.RpcRegistration<OdlMdsalLowlevelControlService> registration;
67 private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
68 private final SchemaService schemaService;
69 private final ClusterSingletonServiceProvider singletonService;
70 private final DOMRpcProviderService domRpcService;
72 private Map<InstanceIdentifier<?>, DOMRpcImplementationRegistration<RoutedGetConstantService>> routedRegistrations =
75 private DOMRpcImplementationRegistration<GetConstantService> globalGetConstantRegistration = null;
76 private ClusterSingletonServiceRegistration getSingletonConstantRegistration;
77 private FlappingSingletonService flappingSingletonService;
79 public MdsalLowLevelTestProvider(final RpcProviderRegistry rpcRegistry,
80 final DOMRpcProviderService domRpcService,
81 final ClusterSingletonServiceProvider singletonService,
82 final SchemaService schemaService,
83 final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
84 this.rpcRegistry = rpcRegistry;
85 this.domRpcService = domRpcService;
86 this.singletonService = singletonService;
87 this.schemaService = schemaService;
88 this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
90 registration = rpcRegistry.addRpcImplementation(OdlMdsalLowlevelControlService.class, this);
94 public Future<RpcResult<Void>> unregisterSingletonConstant() {
95 LOG.debug("unregister-singleton-constant");
97 if (getSingletonConstantRegistration == null) {
98 LOG.debug("No get-singleton-constant registration present.");
99 final RpcError rpcError = RpcResultBuilder
100 .newError(ErrorType.APPLICATION, "missing-registration", "No get-singleton-constant rpc registration present.");
101 final RpcResult<Void> result = RpcResultBuilder.<Void>failed().withRpcError(rpcError).build();
102 return Futures.immediateFuture(result);
106 getSingletonConstantRegistration.close();
107 getSingletonConstantRegistration = null;
109 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
110 } catch (final Exception e) {
111 LOG.debug("There was a problem closing the singleton constant service", e);
112 final RpcError rpcError = RpcResultBuilder
113 .newError(ErrorType.APPLICATION, "error-closing", "There was a problem closing get-singleton-constant");
114 final RpcResult<Void> result = RpcResultBuilder.<Void>failed().withRpcError(rpcError).build();
115 return Futures.immediateFuture(result);
120 public Future<RpcResult<Void>> publishNotifications(PublishNotificationsInput input) {
125 public Future<RpcResult<Void>> subscribeDtcl() {
130 public Future<RpcResult<Void>> writeTransactions(WriteTransactionsInput input) {
135 public Future<RpcResult<IsClientAbortedOutput>> isClientAborted() {
140 public Future<RpcResult<Void>> becomeModuleLeader(BecomeModuleLeaderInput input) {
145 public Future<RpcResult<Void>> removeShardReplica(RemoveShardReplicaInput input) {
150 public Future<RpcResult<Void>> subscribeYnl(SubscribeYnlInput input) {
155 public Future<RpcResult<Void>> becomePrefixLeader(BecomePrefixLeaderInput input) {
160 public Future<RpcResult<Void>> unregisterBoundConstant(final UnregisterBoundConstantInput input) {
161 LOG.debug("unregister-bound-constant, {}", input);
163 final DOMRpcImplementationRegistration<RoutedGetConstantService> registration =
164 routedRegistrations.remove(input.getContext());
166 if (registration == null) {
167 LOG.debug("No get-contexted-constant registration for context: {}", input.getContext());
168 final RpcError rpcError = RpcResultBuilder
169 .newError(ErrorType.APPLICATION, "missing-registration", "No get-constant rpc registration present.");
170 final RpcResult<Void> result = RpcResultBuilder.<Void>failed().withRpcError(rpcError).build();
171 return Futures.immediateFuture(result);
174 registration.close();
175 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
179 public Future<RpcResult<Void>> registerSingletonConstant(final RegisterSingletonConstantInput input) {
181 LOG.debug("Received register-singleton-constant rpc, input: {}", input);
183 if (input.getConstant() == null) {
184 final RpcError error = RpcResultBuilder.newError(
185 ErrorType.RPC, "Invalid input.", "Constant value is null");
186 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
189 getSingletonConstantRegistration =
190 SingletonGetConstantService.registerNew(singletonService, domRpcService, input.getConstant());
192 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
196 public Future<RpcResult<Void>> registerDefaultConstant(RegisterDefaultConstantInput input) {
201 public Future<RpcResult<Void>> unregisterConstant() {
203 if (globalGetConstantRegistration == null) {
204 final RpcError rpcError = RpcResultBuilder
205 .newError(ErrorType.APPLICATION, "missing-registration", "No get-constant rpc registration present.");
206 final RpcResult<Void> result = RpcResultBuilder.<Void>failed().withRpcError(rpcError).build();
207 return Futures.immediateFuture(result);
210 globalGetConstantRegistration.close();
211 globalGetConstantRegistration = null;
213 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
217 public Future<RpcResult<UnregisterFlappingSingletonOutput>> unregisterFlappingSingleton() {
218 LOG.debug("unregister-flapping-singleton received.");
220 if (flappingSingletonService == null) {
221 final RpcError rpcError = RpcResultBuilder
222 .newError(ErrorType.APPLICATION, "missing-registration", "No flapping-singleton registration present.");
223 final RpcResult<UnregisterFlappingSingletonOutput> result =
224 RpcResultBuilder.<UnregisterFlappingSingletonOutput>failed().withRpcError(rpcError).build();
225 return Futures.immediateFuture(result);
228 final long flapCount = flappingSingletonService.setInactive();
229 flappingSingletonService = null;
231 final UnregisterFlappingSingletonOutput output =
232 new UnregisterFlappingSingletonOutputBuilder().setFlapCount(flapCount).build();
234 return Futures.immediateFuture(RpcResultBuilder.success(output).build());
238 public Future<RpcResult<Void>> addShardReplica(AddShardReplicaInput input) {
243 public Future<RpcResult<Void>> subscribeDdtl() {
248 public Future<RpcResult<Void>> registerBoundConstant(final RegisterBoundConstantInput input) {
249 LOG.debug("register-bound-constant: {}", input);
251 if (input.getContext() == null) {
252 final RpcError error = RpcResultBuilder.newError(
253 ErrorType.RPC, "Invalid input.", "Context value is null");
254 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
257 if (input.getConstant() == null) {
258 final RpcError error = RpcResultBuilder.newError(
259 ErrorType.RPC, "Invalid input.", "Constant value is null");
260 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
263 if (routedRegistrations.containsKey(input.getContext())) {
264 final RpcError error = RpcResultBuilder.newError(ErrorType.RPC, "Registration present.",
265 "There is already a rpc registered for context: " + input.getContext());
266 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
269 final DOMRpcImplementationRegistration<RoutedGetConstantService> registration =
270 RoutedGetConstantService.registerNew(bindingNormalizedNodeSerializer, domRpcService,
271 input.getConstant(), input.getContext());
273 routedRegistrations.put(input.getContext(), registration);
274 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
278 public Future<RpcResult<Void>> registerFlappingSingleton() {
279 LOG.debug("Received register-flapping-singleton.");
281 if (flappingSingletonService != null) {
282 final RpcError error = RpcResultBuilder.newError(
283 ErrorType.RPC, "Registration present.", "flappin-singleton already registered");
284 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
287 flappingSingletonService = new FlappingSingletonService(singletonService);
289 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
293 public Future<RpcResult<UnsubscribeDtclOutput>> unsubscribeDtcl() {
298 public Future<RpcResult<Void>> deconfigureIdIntsShard() {
303 public Future<RpcResult<UnsubscribeYnlOutput>> unsubscribeYnl(UnsubscribeYnlInput input) {
308 public Future<RpcResult<Void>> produceTransactions(ProduceTransactionsInput input) {
313 public Future<RpcResult<Void>> registerConstant(final RegisterConstantInput input) {
315 LOG.debug("Received register-constant rpc, input: {}", input);
317 if (input.getConstant() == null) {
318 final RpcError error = RpcResultBuilder.newError(
319 ErrorType.RPC, "Invalid input.", "Constant value is null");
320 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
323 if (globalGetConstantRegistration != null) {
324 final RpcError error = RpcResultBuilder.newError(ErrorType.RPC, "Registration present.",
325 "There is already a get-constant rpc registered.");
326 return Futures.immediateFuture(RpcResultBuilder.<Void>failed().withRpcError(error).build());
329 globalGetConstantRegistration = GetConstantService.registerNew(domRpcService, input.getConstant());
330 return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
334 public Future<RpcResult<Void>> unregisterDefaultConstant() {
339 public Future<RpcResult<UnsubscribeDdtlOutput>> unsubscribeDdtl() {