X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=southbound%2Fsouthbound-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Fsouthbound%2Fovsdb%2Ftransact%2FControllerUpdateCommand.java;h=98e62de3c5881ea72c194e4ad81eba0ae4ac94b3;hb=HEAD;hp=1546a6aa4a969c71bf209bd525d03dc242daa9ac;hpb=12afe26372129b154a9e96409f04ba916e872264;p=ovsdb.git

diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/ControllerUpdateCommand.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/ControllerUpdateCommand.java
index 1546a6aa4..98e62de3c 100644
--- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/ControllerUpdateCommand.java
+++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/ControllerUpdateCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
+ * Copyright © 2014, 2017 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,
@@ -9,71 +9,82 @@ package org.opendaylight.ovsdb.southbound.ovsdb.transact;
 
 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
 
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Map.Entry;
-
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
 import org.opendaylight.ovsdb.lib.notation.Mutator;
 import org.opendaylight.ovsdb.lib.notation.UUID;
 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
-import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
 import org.opendaylight.ovsdb.schema.openvswitch.Controller;
+import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
-import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class ControllerUpdateCommand extends AbstractTransactCommand {
+public class ControllerUpdateCommand implements TransactCommand {
     private static final Logger LOG = LoggerFactory.getLogger(ControllerUpdateCommand.class);
 
-    public ControllerUpdateCommand(BridgeOperationalState state,
-            AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
-        super(state, changes);
+    @Override
+    public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final DataChangeEvent events, final InstanceIdentifierCodec instanceIdentifierCodec) {
+        execute(transaction, state, TransactUtils.extractCreatedOrUpdated(events, ControllerEntry.class),
+                TransactUtils.extractCreatedOrUpdated(events, OvsdbBridgeAugmentation.class));
     }
 
     @Override
-    public void execute(TransactionBuilder transaction) {
-        Map<InstanceIdentifier<ControllerEntry>, ControllerEntry> controllers =
-                TransactUtils.extractCreatedOrUpdated(getChanges(), ControllerEntry.class);
-        Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> bridges =
-                TransactUtils.extractCreatedOrUpdated(getChanges(), OvsdbBridgeAugmentation.class);
-        LOG.info("execute: controllers: {} --- bridges: {}", controllers, bridges);
+    public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final Collection<DataTreeModification<Node>> modifications,
+            final InstanceIdentifierCodec instanceIdentifierCodec) {
+        execute(transaction, state, TransactUtils.extractCreatedOrUpdated(modifications, ControllerEntry.class),
+                TransactUtils.extractCreatedOrUpdated(modifications, OvsdbBridgeAugmentation.class));
+    }
+
+    private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final Map<InstanceIdentifier<ControllerEntry>, ControllerEntry> controllers,
+            final Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> bridges) {
+        LOG.info("Register ODL controllers : {}  bridges detail : {}",
+                controllers, bridges);
         for (Entry<InstanceIdentifier<ControllerEntry>, ControllerEntry> entry: controllers.entrySet()) {
             Optional<ControllerEntry> operationalControllerEntryOptional =
-                    getOperationalState().getControllerEntry(entry.getKey());
+                    state.getControllerEntry(entry.getKey());
             if (!operationalControllerEntryOptional.isPresent()) {
                 InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
                         entry.getKey().firstIdentifierOf(OvsdbBridgeAugmentation.class);
                 Optional<OvsdbBridgeAugmentation> bridgeOptional =
-                        getOperationalState().getOvsdbBridgeAugmentation(bridgeIid);
-                OvsdbBridgeAugmentation ovsdbBridge = null;
-                if (bridgeOptional.isPresent()) {
-                    ovsdbBridge = bridgeOptional.get();
-                } else {
-                    ovsdbBridge = bridges.get(bridgeIid);
-                }
+                        state.getOvsdbBridgeAugmentation(bridgeIid);
+                OvsdbBridgeAugmentation ovsdbBridge = bridgeOptional.isPresent()
+                    ? bridgeOptional.orElseThrow() : bridges.get(bridgeIid);
                 if (ovsdbBridge != null
                         && ovsdbBridge.getBridgeName() != null
                         && entry.getValue() != null
                         && entry.getValue().getTarget() != null) {
-                    Controller controller =
-                            TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Controller.class);
-                    controller.setTarget(entry.getValue().getTarget().getValue());
-                    String controllerNamedUuidString = SouthboundMapper.getRandomUUID();
+                    ControllerEntry controllerEntry = entry.getValue();
+                    Controller controller = transaction.getTypedRowWrapper(Controller.class);
+                    controller.setTarget(controllerEntry.getTarget().getValue());
+                    if (controllerEntry.getMaxBackoff() != null) {
+                        controller.setMaxBackoff(Collections.singleton(controllerEntry.getMaxBackoff().toJava()));
+                    }
+                    if (controllerEntry.getInactivityProbe() != null) {
+                        controller.setInactivityProbe(Collections.singleton(
+                            controllerEntry.getInactivityProbe().toJava()));
+                    }
+                    String controllerNamedUuidString = SouthboundMapper.getRandomUuid();
                     UUID controllerNamedUuid = new UUID(controllerNamedUuidString);
                     transaction.add(op.insert(controller).withId(controllerNamedUuidString));
 
-                    Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
+                    Bridge bridge = transaction.getTypedRowWrapper(Bridge.class);
                     bridge.setName(ovsdbBridge.getBridgeName().getValue());
-                    bridge.setController(Sets.newHashSet(controllerNamedUuid));
-                    LOG.info("execute: bridge: {}", bridge);
+                    bridge.setController(Collections.singleton(controllerNamedUuid));
+                    LOG.trace("Added controller : {} for bridge : {}",
+                            controller.getTargetColumn(), bridge.getName());
                     transaction.add(op.mutate(bridge)
                             .addMutation(bridge.getControllerColumn().getSchema(), Mutator.INSERT,
                                     bridge.getControllerColumn().getData())
@@ -82,8 +93,7 @@ public class ControllerUpdateCommand extends AbstractTransactCommand {
                 }
             }
         }
-        LOG.info("execute: transaction: {}", transaction.build());
+        LOG.trace("Executed transaction: {}", transaction.build());
 
     }
-
 }