<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-persister-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>netconf-features</artifactId>
- <version>${netconf.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>features-odl-protocol-framework</artifactId>
- <version>${protocol-framework.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<artifactId>filter-valve</artifactId>
<version>${filtervalve.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>flow-management-compatibility</artifactId>
- <version>${mdsal.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>flowprogrammer.northbound</artifactId>
<artifactId>sal-distributed-datastore</artifactId>
<version>${mdsal.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-clustering-commons</artifactId>
+ <version>${mdsal.version}</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>model-flow-base</artifactId>
<version>${mdsal.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <version>${mdsal.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
<version>${yangtools.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-odl-protocol-framework</artifactId>
+ <version>${protocol-framework.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>netconf-features</artifactId>
+ <version>${netconf.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-persister-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-netty-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-adsal</artifactId>
+ <version>${sal.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>mdsal-features</artifactId>
+ <version>${mdsal.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
</dependencies>
</dependencyManagement>
<capability>urn:opendaylight:params:xml:ns:yang:controller:netty:timer?module=netty-timer&revision=2013-11-19</capability>
</required-capabilities>
<configuration>
-
+
<data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
<module>
<name>singleton</name>
</module>
</modules>
-
+
<services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
<service>
<type xmlns:netty="urn:opendaylight:params:xml:ns:yang:controller:netty">netty:netty-threadgroup</type>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-netty-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>features-adsal</artifactId>
- <version>${sal.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-features</artifactId>
- <version>${mdsal.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-distributed-datastore</artifactId>
</dependency>
-
</dependencies>
</profile>
<profile>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>compatibility-parent</artifactId>
- <version>1.1-SNAPSHOT</version>
- </parent>
- <artifactId>flow-management-compatibility</artifactId>
- <packaging>bundle</packaging>
-
- <dependencies>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>forwardingrulesmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-compatibility</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
- <scope>test</scope>
- </dependency>
-
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Name>Forwarding Rules Manager Adapter for MD-SAL</Bundle-Name>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <scm>
- <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
- <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
- <tag>HEAD</tag>
- <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
- </scm>
-</project>
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.FlowsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class ConfigurationReader implements FlowManagementReader {
-
- private final static Logger LOG = LoggerFactory.getLogger(ConfigurationReader.class);
-
- private IForwardingRulesManager manager;
-
- @Override
- public Flows readAllFlows() {
- List<FlowConfig> staticFlows = this.manager.getStaticFlows();
- List<Flow> flowMap = new ArrayList<Flow>(staticFlows.size());
-
- for (FlowConfig conf : staticFlows) {
- flowMap.add(FlowConfigMapping.toConfigurationFlow(conf));
- }
- final FlowsBuilder flowsBuilder = new FlowsBuilder();
- return (flowsBuilder.setFlow(flowMap)).build();
- }
-
- @Override
- public Flow readFlow(final FlowKey key) {
- try {
- final FlowConfig flowConf =
- this.manager.getStaticFlow(String.valueOf(key.getId()), NodeMapping.toADNode(key.getNode()));
- return FlowConfigMapping.toConfigurationFlow(flowConf);
- } catch (Exception e) {
- String errMsg = MessageFormat.format("readFlow by key {} fail", key);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public IForwardingRulesManager getManager() {
- return this.manager;
- }
-
- public void setManager(final IForwardingRulesManager manager) {
- this.manager = manager;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
-import org.opendaylight.controller.md.sal.common.api.data.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
-import org.opendaylight.controller.md.sal.common.api.data.DataModification;
-import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.common.util.Arguments;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yangtools.concepts.Registration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-
-public class FRMRuntimeDataProvider implements RuntimeDataProvider, DataCommitHandler<InstanceIdentifier<? extends DataObject>,DataObject> {
-
- private final static InstanceIdentifier<Flows> FLOWS_PATH = InstanceIdentifier.<Flows> builder(Flows.class).toInstance();
-
- private final FlowManagementReader configuration = new ConfigurationReader();
- private DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> changeListener;
- private DataProviderService dataService;
- private IForwardingRulesManager manager;
-
- public Registration init() {
- return this.dataService.registerCommitHandler(FRMRuntimeDataProvider.FLOWS_PATH, this);
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- return this.readFrom(this.configuration, path);
- }
-
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- return this.readFrom(this.configuration, path);
- }
-
- public DataObject readFrom(final FlowManagementReader store, final InstanceIdentifier<? extends DataObject> path) {
- if (Objects.equal(FRMRuntimeDataProvider.FLOWS_PATH, path)) {
- return store.readAllFlows();
- }
- if (FRMRuntimeDataProvider.FLOWS_PATH.contains(path)) {
- return store.readFlow(this.toFlowKey(path));
- }
- return null;
- }
-
- @Override
- public FlowCommitTransaction requestCommit(final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
- return new FlowCommitTransaction(this, modification);
- }
-
- public FlowKey toFlowKey(final InstanceIdentifier<? extends DataObject> identifier) {
- Preconditions.<InstanceIdentifier<? extends DataObject>> checkNotNull(identifier);
-
- Iterable<PathArgument> path = identifier.getPathArguments();
- PathArgument get = path.iterator().next();
- final Identifier itemKey = Arguments.<IdentifiableItem> checkInstanceOf(get, IdentifiableItem.class).getKey();
- return Arguments.<FlowKey> checkInstanceOf(itemKey, FlowKey.class);
- }
-
- public RpcResult<Void> finish(final FlowCommitTransaction transaction) {
- Iterable<FlowConfig> toRemove = transaction.getToRemove();
- for (final FlowConfig flow : toRemove) {
- this.manager.removeStaticFlow(flow.getName(), flow.getNode());
- }
- Iterable<FlowConfig> toUpdate = transaction.getToUpdate();
- for (final FlowConfig flow : toUpdate) {
- this.manager.removeStaticFlow(flow.getName(), flow.getNode());
- this.manager.addStaticFlow(flow);
- }
- return RpcResultBuilder.<Void> success().build();
- }
-
- public RpcResult<Void> rollback(final FlowCommitTransaction transaction) {
- return null;
- }
-
- public DataProviderService getDataService() {
- return this.dataService;
- }
-
- public void setDataService(final DataProviderService dataService) {
- this.dataService = dataService;
- }
-
- public DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> getChangeListener() {
- return this.changeListener;
- }
-
- public void setChangeListener(final DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> changeListener) {
- this.changeListener = changeListener;
- }
-
- public IForwardingRulesManager getManager() {
- return this.manager;
- }
-
- public void setManager(final IForwardingRulesManager manager) {
- this.manager = manager;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.DataModification;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-
-public class FlowCommitTransaction implements DataCommitTransaction<InstanceIdentifier<? extends DataObject>, DataObject> {
-
- private final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification;
- private final HashSet<FlowConfig> toAdd = new HashSet<FlowConfig>();
- private final FRMRuntimeDataProvider flowManager;
- private Iterable<FlowConfig> toUpdate;
- private Iterable<FlowConfig> toRemove;
-
- public FlowCommitTransaction(
- final FRMRuntimeDataProvider flowManager,
- final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
- this.flowManager = flowManager;
- this.modification = modification;
- this.processModification();
- }
-
- @Override
- public RpcResult<Void> finish() throws IllegalStateException {
- return this.flowManager.finish(this);
- }
-
- @Override
- public RpcResult<Void> rollback() throws IllegalStateException {
- return this.flowManager.rollback(this);
- }
-
- public void processModification() {
- final Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> updated =
- this.modification.getUpdatedConfigurationData().entrySet();
- final List<FlowConfig> forUpdate = new ArrayList<FlowConfig>(updated.size());
-
- if (updated != null && !(updated.isEmpty())) {
- for (Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : updated) {
- if (FlowConfigMapping.isFlowPath(entry.getKey())) {
- forUpdate.add(FlowConfigMapping.toFlowConfig((Flow) entry.getValue()));
- }
- }
- }
- this.toUpdate = Collections.unmodifiableCollection(forUpdate);
-
- final Set<InstanceIdentifier<? extends DataObject>> removedConfigurationData =
- this.modification.getRemovedConfigurationData();
- final List<FlowConfig> forRemove = new ArrayList<FlowConfig>(removedConfigurationData.size());
-
- if (removedConfigurationData != null && !(removedConfigurationData.isEmpty())) {
- for (InstanceIdentifier<? extends DataObject> data : removedConfigurationData) {
- if (FlowConfigMapping.isFlowPath(data)) {
- forRemove.add(FlowConfigMapping.toFlowConfig(data));
- }
- }
- }
- this.toRemove = Collections.unmodifiableCollection(forRemove);
- }
-
- @Override
- public DataModification<InstanceIdentifier<? extends DataObject>, DataObject> getModification() {
- return this.modification;
- }
-
- public FRMRuntimeDataProvider getFlowManager() {
- return this.flowManager;
- }
-
- public HashSet<FlowConfig> getToAdd() {
- return this.toAdd;
- }
-
- public Iterable<FlowConfig> getToUpdate() {
- return this.toUpdate;
- }
-
- public Iterable<FlowConfig> getToRemove() {
- return this.toRemove;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import java.text.MessageFormat;
-import java.util.Iterator;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.sal.compatibility.MDFlowMapping;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAdded;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class FlowConfigMapping {
-
- private final static Logger LOG = LoggerFactory.getLogger(FlowConfigMapping.class);
-
- /* nodes/node/flow -> 0 / 1 / 2 */
- private static final int FLOW_KEY_IDENTIFIER_DEEP = 2;
-
- public static Flow toConfigurationFlow(final FlowConfig sourceCfg) {
- final FlowAdded source = MDFlowMapping.flowAdded(sourceCfg.getFlow());
- final FlowBuilder flowBuilder = new FlowBuilder();
- flowBuilder.setInstructions(source.getInstructions());
- flowBuilder.setCookie(source.getCookie());
- flowBuilder.setHardTimeout(source.getHardTimeout());
- flowBuilder.setIdleTimeout(source.getIdleTimeout());
- flowBuilder.setMatch(source.getMatch());
- flowBuilder.setNode(source.getNode());
-
- FlowKey flowKey =
- new FlowKey(Long.valueOf(sourceCfg.getName()), flowBuilder.getNode());
- flowBuilder.setKey(flowKey);
- return flowBuilder.build();
- }
-
- public static FlowConfig toFlowConfig(final Flow sourceCfg) {
- try {
- final FlowConfig flowConfig = new FlowConfig();
- flowConfig.setName(String.valueOf(sourceCfg.getId()));
- flowConfig.setNode(NodeMapping.toADNode(sourceCfg.getNode()));
- return flowConfig;
- } catch (Exception e) {
- String errMsg = MessageFormat.format("Convert from Flow {} to FlowConfig fail", sourceCfg);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public static FlowConfig toFlowConfig(final InstanceIdentifier<? extends Object> identifier) {
- try {
- PathArgument pathArg = FlowConfigMapping.getSecondPathArgumentFromPath(identifier);
- if (pathArg != null) {
- final FlowConfig flowConfig = new FlowConfig();
- FlowKey key = ((IdentifiableItem<Flow, FlowKey>) pathArg).getKey();
- flowConfig.setName(String.valueOf(key.getId()));
- flowConfig.setNode(NodeMapping.toADNode(key.getNode()));
- return flowConfig;
- }
- return null;
- } catch (Exception e) {
- String errMsg = MessageFormat.format("Convert from InstanceIdentifier {} to FlowConfig fail", identifier);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public static boolean isFlowPath(final InstanceIdentifier<? extends Object> path) {
- PathArgument pathArg = FlowConfigMapping.getSecondPathArgumentFromPath(path);
- if (pathArg == null) {
- return false;
- }
- if (pathArg instanceof IdentifiableItem<?,?>) {
- final Identifiable<?> key = ((IdentifiableItem<?, ? extends Identifiable<?>>) pathArg).getKey();
- if ((key instanceof FlowKey)) {
- return true;
- }
- }
- return false;
- }
-
- private static PathArgument getSecondPathArgumentFromPath(final InstanceIdentifier<? extends Object> path) {
- if (path != null && path.getPathArguments() != null) {
- Iterator<PathArgument> iterator = path.getPathArguments().iterator();
- int deep = 0;
- while (iterator.hasNext()) {
- PathArgument pathArg = iterator.next();
- if (deep == FlowConfigMapping.FLOW_KEY_IDENTIFIER_DEEP) {
- return pathArg;
- }
- deep++;
- }
- }
- return null;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-
-public interface FlowManagementReader {
-
- Flows readAllFlows();
-
- Flow readFlow(FlowKey key);
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.frm.compatibility;
-
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext;
-import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class SampleConsumer {
-
- ConsumerContext context;
-
- void addFlowExample() {
-
- DataBrokerService dataService = context.getSALService(DataBrokerService.class);
-
- DataModificationTransaction transaction = dataService.beginTransaction();
- Flow flow = createSampleFlow("foo", null);
- InstanceIdentifier<Flow> path = InstanceIdentifier.builder(Flows.class).child(Flow.class, flow.getKey())
- .toInstance();
- transaction.putConfigurationData(path, flow);
-
- transaction.commit();
-
- dataService.readConfigurationData(path);
- }
-
- Flow createSampleFlow(String name, NodeRef node) {
- FlowBuilder ret = new FlowBuilder();
- FlowKey key = new FlowKey(Long.parseLong(name), node);
- ret.setKey(key);
- return ret.build();
- }
-}
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>compatibility-parent</artifactId>
- <version>1.1-SNAPSHOT</version>
- </parent>
- <artifactId>inventory-topology-compatibility</artifactId>
- <packaging>bundle</packaging>
-
- <dependencies>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>forwardingrulesmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-compatibility</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>switchmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>topologymanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-topology</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
- <scope>test</scope>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Name>Forwarding Rules Manager Adapter
- for MD-SAL</Bundle-Name>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <scm>
- <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
- <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
- <tag>HEAD</tag>
- <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
- </scm>
-</project>
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.inventory;
-
-import java.util.ArrayList;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.compatibility.InventoryMapping;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class InventoryReader implements RuntimeDataProvider {
- private static final Logger LOG = LoggerFactory.getLogger(InventoryReader.class);
- private ISwitchManager switchManager;
-
- public ISwitchManager getSwitchManager() {
- return switchManager;
- }
-
- public void setSwitchManager(final ISwitchManager switchManager) {
- this.switchManager = switchManager;
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- // Topology and Inventory are operational only
- return null;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- final Class<? extends DataObject> type = path.getTargetType();
- if (Nodes.class.equals(type)) {
- return readNodes(((InstanceIdentifier<Nodes>) path));
- }
- if (Node.class.equals(type)) {
- return readNode(((InstanceIdentifier<Node>) path));
- }
- if (NodeConnector.class.equals(type)) {
- return readNodeConnector(((InstanceIdentifier<NodeConnector>) path));
- }
-
- LOG.debug("Unsupported type {}", type);
- return null;
- }
-
- private NodeConnector readNodeConnector(final InstanceIdentifier<NodeConnector> identifier) {
- return constructNodeConnector(InventoryMapping.toAdNodeConnector(identifier));
- }
-
- private Node readNode(final InstanceIdentifier<Node> identifier) {
- return constructNode(InventoryMapping.toAdNode(identifier));
- }
-
- private Node constructNode(final org.opendaylight.controller.sal.core.Node node) {
- final Set<org.opendaylight.controller.sal.core.NodeConnector> connectors = getSwitchManager().getNodeConnectors(node);
- final ArrayList<NodeConnector> tpList = new ArrayList<NodeConnector>(connectors.size());
- for (final org.opendaylight.controller.sal.core.NodeConnector connector : connectors) {
- tpList.add(constructNodeConnector(connector));
- }
-
- return new NodeBuilder()
- .setKey(InventoryMapping.toNodeKey(node))
- .setNodeConnector(tpList)
- .build();
- }
-
- private Nodes readNodes(final InstanceIdentifier<Nodes> identifier) {
- final Set<org.opendaylight.controller.sal.core.Node> nodes = getSwitchManager().getNodes();
- final ArrayList<Node> nodeList = new ArrayList<Node>(nodes.size());
- for (final org.opendaylight.controller.sal.core.Node node : nodes) {
- nodeList.add(constructNode(node));
- }
-
- return new NodesBuilder().setNode(nodeList).build();
- }
-
- private static NodeConnector constructNodeConnector(final org.opendaylight.controller.sal.core.NodeConnector connector) {
- return new NodeConnectorBuilder().setKey(InventoryMapping.toNodeConnectorKey(connector)).build();
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.switchmanager;
-
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.net.SocketException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.controller.sal.core.Bandwidth;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Description;
-import org.opendaylight.controller.sal.core.ForwardingMode;
-import org.opendaylight.controller.sal.core.MacAddress;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.Tier;
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.switchmanager.Subnet;
-import org.opendaylight.controller.switchmanager.Switch;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class CompatibleSwitchManager extends ConfigurableSwitchManager implements ISwitchManager {
- private static final Logger LOG = LoggerFactory.getLogger(CompatibleSwitchManager.class);
-
- private DataBrokerService _dataService;
-
- public DataBrokerService getDataService() {
- return this._dataService;
- }
-
- public void setDataService(final DataBrokerService dataService) {
- this._dataService = dataService;
- }
-
- @Override
- public Status addNodeConnectorProp(final NodeConnector nodeConnector, final Property prop) {
- final DataModificationTransaction it = getDataService().beginTransaction();
- final NodeConnectorRef path = NodeMapping.toNodeConnectorRef(nodeConnector);
- return null;
- }
-
- @Override
- public Property createProperty(final String propName, final String propValue) {
- try {
- if (propName.equalsIgnoreCase(Description.propertyName)) {
- return new Description(propValue);
- } else if (propName.equalsIgnoreCase(Tier.TierPropName)) {
- return new Tier(Integer.parseInt(propValue));
- } else if (propName.equalsIgnoreCase(Bandwidth.BandwidthPropName)) {
- return new Bandwidth(Long.parseLong(propValue));
- } else if (propName.equalsIgnoreCase(ForwardingMode.name)) {
- return new ForwardingMode(Integer.parseInt(propValue));
- } else if (propName.equalsIgnoreCase(MacAddress.name)) {
- return new MacAddress(propValue);
- } else {
- LOG.debug("Not able to create {} property", propName);
- }
- } catch (Exception e) {
- LOG.debug("createProperty caught exception {}", e.getMessage());
- }
-
- return null;
- }
-
- @Override
- public boolean doesNodeConnectorExist(final NodeConnector nc) {
- return (getDataService().readOperationalData(NodeMapping.toNodeConnectorRef(nc).getValue()) != null);
- }
-
- @Override
- public byte[] getControllerMAC() {
- final Enumeration<NetworkInterface> nis;
- try {
- nis = NetworkInterface.getNetworkInterfaces();
- } catch (SocketException e) {
- LOG.error("Failed to acquire list of interfaces, cannot determine controller MAC", e);
- return null;
- }
-
- while (nis.hasMoreElements()) {
- final NetworkInterface ni = nis.nextElement();
- try {
- return ni.getHardwareAddress();
- } catch (SocketException e) {
- LOG.error("Failed to acquire controller MAC from interface {}", ni, e);
- }
- }
-
- // This happens when running controller on windows VM, for example
- // Try parsing the OS command output
- LOG.warn("Failed to acquire controller MAC: No physical interface found");
- return null;
- }
-
- @Override
- public Map<String,Property> getControllerProperties() {
- return Collections.<String, Property>emptyMap();
- }
-
- @Override
- public Property getControllerProperty(final String propertyName) {
- return null;
- }
-
- @Override
- public List<Switch> getNetworkDevices() {
- final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).toInstance();
- final Nodes data = ((Nodes) getDataService().readOperationalData(path));
- final ArrayList<Switch> ret = new ArrayList<>();
- for (final Node node : data.getNode()) {
- try {
- ret.add(toSwitch(node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create switch {}", node), e);
- }
- }
- return ret;
- }
-
- @Override
- public NodeConnector getNodeConnector(final org.opendaylight.controller.sal.core.Node node, final String nodeConnectorName) {
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(nodeConnectorName));
- try {
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, node);
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node connector for {} {}", node, nodeConnectorName), e);
- }
- }
-
- @Override
- public Property getNodeConnectorProp(final NodeConnector nodeConnector, final String propName) {
- return getNodeConnectorProps(nodeConnector).get(propName);
- }
-
- @Override
- public Map<String,Property> getNodeConnectorProps(final NodeConnector nodeConnector) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(nodeConnector);
- return toAdProperties(readNodeConnector(ref.getValue()));
- }
-
- @Override
- public Set<NodeConnector> getNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final Node data = this.readNode(NodeMapping.toNodeRef(node).getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node {} connector", node, nc.getKey()), e);
- }
- }
- return ret;
- }
-
- @Override
- public String getNodeDescription(final org.opendaylight.controller.sal.core.Node node) {
- return ((Description) getNodeProps(node).get(Description.propertyName)).getValue();
- }
-
- @Override
- public byte[] getNodeMAC(final org.opendaylight.controller.sal.core.Node node) {
- return ((MacAddress) getNodeProps(node).get(MacAddress.name)).getMacAddress();
- }
-
- @Override
- public Property getNodeProp(final org.opendaylight.controller.sal.core.Node node, final String propName) {
- return getNodeProps(node).get(propName);
- }
-
- @Override
- public Map<String,Property> getNodeProps(final org.opendaylight.controller.sal.core.Node node) {
- final NodeRef ref = NodeMapping.toNodeRef(node);
- return toAdProperties(((Node) getDataService().readOperationalData(ref.getValue())));
- }
-
- @Override
- public Set<org.opendaylight.controller.sal.core.Node> getNodes() {
- final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).toInstance();
- final Nodes data = ((Nodes) getDataService().readOperationalData(path));
- final HashSet<org.opendaylight.controller.sal.core.Node> ret = new HashSet<>();
- for (final Node node : data.getNode()) {
- try {
- ret.add(new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, node.getKey()));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node for {}", node), e);
- }
- }
- return ret;
- }
-
- private static Switch toSwitch(final Node node) throws ConstructionException {
- return new Switch(new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, node.getKey()));
- }
-
- @Override
- public Set<NodeConnector> getPhysicalNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final NodeRef ref = NodeMapping.toNodeRef(node);
- final Node data = readNode(ref.getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- final FlowCapableNodeConnector flowConnector = nc.getAugmentation(FlowCapableNodeConnector.class);
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create connector for {} on node {}", nc.getKey(), node), e);
- }
- }
- return ret;
- }
-
- private static Map<String,Property> toAdProperties(final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector connector) {
- return Collections.emptyMap();
- }
-
- private static Map<String,Property> toAdProperties(final Node connector) {
- return Collections.emptyMap();
- }
-
- private Node readNode(final InstanceIdentifier<? extends Object> ref) {
- return (Node) getDataService().readOperationalData((ref));
- }
-
- private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector readNodeConnector(final InstanceIdentifier<? extends Object> ref) {
- return ((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) getDataService().readOperationalData(ref));
- }
-
- @Override
- public List<NodeConnector> getSpanPorts(final org.opendaylight.controller.sal.core.Node node) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Subnet getSubnetByNetworkAddress(final InetAddress networkAddress) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Set<NodeConnector> getUpNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final Node data = readNode(NodeMapping.toNodeRef(node).getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- final FlowCapableNodeConnector flowConn = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
- if (flowConn != null && flowConn.getState() != null && !flowConn.getState().isLinkDown()) {
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node connector for node {} connector {}", node, nc), e);
- }
- }
- }
- return ret;
- }
-
- @Override
- public Boolean isNodeConnectorEnabled(final NodeConnector nodeConnector) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(nodeConnector);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector data = readNodeConnector(ref.getValue());
- return true;
- }
-
- @Override
- public boolean isSpecial(final NodeConnector p) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(p);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector data = readNodeConnector(ref.getValue());
- return true;
- }
-
- @Override
- public Status removeControllerProperty(final String propertyName) {
- return null;
- }
-
- @Override
- public Status removeNodeAllProps(final org.opendaylight.controller.sal.core.Node node) {
- return null;
- }
-
- @Override
- public Status removeNodeConnectorAllProps(final NodeConnector nodeConnector) {
- return null;
- }
-
- @Override
- public Status removeNodeConnectorProp(final NodeConnector nc, final String propName) {
- return null;
- }
-
- @Override
- public Status removeNodeProp(final org.opendaylight.controller.sal.core.Node node, final String propName) {
- return null;
- }
-
- @Override
- public Status removePortsFromSubnet(final String name, final List<String> nodeConnectors) {
- return null;
- }
-
- @Override
- public Status removeSubnet(final String name) {
- return null;
- }
-
- @Override
- public Status setControllerProperty(final Property property) {
- return null;
- }
-
- @Override
- public void setNodeProp(final org.opendaylight.controller.sal.core.Node node, final Property prop) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status addPortsToSubnet(final String name, final List<String> nodeConnectors) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Set<Switch> getConfiguredNotConnectedSwitches() {
- return null;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.switchmanager;
-
-import java.util.List;
-
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.switchmanager.SpanConfig;
-import org.opendaylight.controller.switchmanager.SubnetConfig;
-import org.opendaylight.controller.switchmanager.SwitchConfig;
-
-/**
- * These methods should be backed by config subsystem.
- */
-public abstract class ConfigurableSwitchManager implements ISwitchManager {
- @Override
- public Status saveSwitchConfig() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status removeSpanConfig(final SpanConfig cfgObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status addSubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status addSpanConfig(final SpanConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final List<SpanConfig> getSpanConfigList() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final void updateSwitchConfig(final SwitchConfig cfgObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status updateNodeConfig(final SwitchConfig switchConfig) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final SubnetConfig getSubnetConfig(final String subnet) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status removeNodeConfig(final String nodeId) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status removeSubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final List<SubnetConfig> getSubnetsConfigList() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final SwitchConfig getSwitchConfig(final String nodeId) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status modifySubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.topology;
-
-import java.util.Iterator;
-
-import org.opendaylight.controller.sal.compatibility.InventoryMapping;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.LinkId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-
-import com.google.common.base.Splitter;
-
-public class TopologyMapping {
- private static final String HEAD_TAIL_STRING = "::::";
- private static final Splitter HEAD_TAIL_SPLITTER = Splitter.on(HEAD_TAIL_STRING);
-
- public TopologyMapping(final TopologyKey path, final InstanceIdentifier<Topology> key) {
- // No-op for now. Multi-instance will require fixing InventoryMapping first.
- }
-
- public Edge toAdTopologyEdge(final InstanceIdentifier<Link> identifier) throws ConstructionException {
- @SuppressWarnings("unchecked")
- final LinkKey linkKey = ((KeyedInstanceIdentifier<Link, LinkKey>)identifier).getKey();
-
- final Iterator<String> it = HEAD_TAIL_SPLITTER.split(linkKey.getLinkId().getValue()).iterator();
- final NodeConnector tail = InventoryMapping.nodeConnectorFromId(it.next());
- final NodeConnector head = InventoryMapping.nodeConnectorFromId(it.next());
- return new Edge(tail, head);
- }
-
- public NodeConnector toAdTopologyNodeConnector(final InstanceIdentifier<TerminationPoint> identifier) {
- @SuppressWarnings("unchecked")
- final TerminationPointKey tpKey = ((KeyedInstanceIdentifier<TerminationPoint, TerminationPointKey>)identifier).getKey();
-
- return InventoryMapping.nodeConnectorFromId(tpKey.getTpId().getValue());
- }
-
- public org.opendaylight.controller.sal.core.Node toAdTopologyNode(final InstanceIdentifier<Node> identifier) {
- @SuppressWarnings("unchecked")
- final NodeKey nodeKey = ((KeyedInstanceIdentifier<Node, NodeKey>)identifier).getKey();
-
- return InventoryMapping.nodeFromNodeId(nodeKey.getNodeId().getValue());
- }
-
- public NodeKey toTopologyNodeKey(final org.opendaylight.controller.sal.core.Node node) {
- return new NodeKey(new NodeId(InventoryMapping.toNodeId(node)));
- }
-
- public TerminationPointKey toTopologyTerminationPointKey(final NodeConnector nc) {
- return new TerminationPointKey(new TpId(InventoryMapping.toNodeConnectorId(nc)));
- }
-
- public LinkKey toTopologyLinkKey(final Edge edge) {
- final TerminationPointKey sourceTp = toTopologyTerminationPointKey(edge.getTailNodeConnector());
- final TerminationPointKey destTp = toTopologyTerminationPointKey(edge.getHeadNodeConnector());
-
- final StringBuilder sb = new StringBuilder();
- sb.append(sourceTp.getTpId().toString());
- sb.append(HEAD_TAIL_STRING);
- sb.append(destTp.getTpId().toString());
- return new LinkKey(new LinkId(sb.toString()));
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.topology;
-
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.DestinationBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.SourceBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class TopologyReader implements RuntimeDataProvider {
- private static final Logger LOG = LoggerFactory.getLogger(TopologyReader.class);
- private final InstanceIdentifier<Topology> topologyPath;
- private final TopologyKey topologyKey;
- private final TopologyMapping mapping;
- private ITopologyManager topologyManager;
- private ISwitchManager switchManager;
-
- public ISwitchManager getSwitchManager() {
- return this.switchManager;
- }
-
- public void setSwitchManager(final ISwitchManager switchManager) {
- this.switchManager = switchManager;
- }
-
- public ITopologyManager getTopologyManager() {
- return this.topologyManager;
- }
-
- public void setTopologyManager(final ITopologyManager topologyManager) {
- this.topologyManager = topologyManager;
- }
-
- public TopologyKey getTopologyKey() {
- return this.topologyKey;
- }
-
- public TopologyMapping getMapping() {
- return this.mapping;
- }
-
- public TopologyReader() {
- this.topologyKey = new TopologyKey(new TopologyId("compatibility:ad-sal"));
- this.topologyPath = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, topologyKey)
- .toInstance();
- this.mapping = new TopologyMapping(topologyKey, topologyPath);
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- // Topology and Inventory are operational only
- return null;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- if (!topologyPath.contains(path)) {
- return null;
- }
-
- final Class<? extends DataObject> type = path.getTargetType();
- if (Link.class.equals(type)) {
- return readLink((InstanceIdentifier<Link>) path);
- }
- if (Node.class.equals(type)) {
- return readNode((InstanceIdentifier<Node>) path);
- }
- if (TerminationPoint.class.equals(type)) {
- return readTerminationPoint((InstanceIdentifier<TerminationPoint>) path);
-
- }
- if (Topology.class.equals(type)) {
- return readTopology((InstanceIdentifier<Topology>) path);
- }
-
- LOG.debug("Unsupported type {}", type);
- return null;
- }
-
- private Link readLink(final InstanceIdentifier<Link> identifier) {
- final Edge edge;
- try {
- edge = this.mapping.toAdTopologyEdge(identifier);
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to construct edge for link %s", identifier), e);
- }
-
- final Map<Edge,Set<Property>> edges;
- if (topologyManager != null) {
- edges = topologyManager.getEdges();
- } else {
- edges = null;
- }
-
- final Set<Property> properties;
- if (edges != null) {
- properties = edges.get(edge);
- } else {
- properties = null;
- }
-
- return constructLink(edge);
- }
-
- private TerminationPoint readTerminationPoint(final InstanceIdentifier<TerminationPoint> identifier) {
- return constructTerminationPoint(mapping.toAdTopologyNodeConnector(identifier));
- }
-
- private Node readNode(final InstanceIdentifier<Node> identifier) {
- return constructNode(mapping.toAdTopologyNode(identifier));
- }
-
- private Topology readTopology(final InstanceIdentifier<Topology> identifier) {
- final Set<org.opendaylight.controller.sal.core.Node> nodes = getSwitchManager().getNodes();
- final ArrayList<Node> nodeList = new ArrayList<Node>(nodes.size());
- for (final org.opendaylight.controller.sal.core.Node node : nodes) {
- nodeList.add(constructNode(node));
- }
-
- final Map<Edge,Set<Property>> edges = getTopologyManager().getEdges();
- final ArrayList<Link> linkList = new ArrayList<Link>(edges.size());
- for (final Edge edge : edges.keySet()) {
- linkList.add(constructLink(edge));
- }
-
- return new TopologyBuilder()
- .setKey(topologyKey)
- .setNode(nodeList)
- .setLink(linkList)
- .build();
- }
-
- private Link constructLink(final Edge edge) {
- final NodeConnector sourceNc = edge.getTailNodeConnector();
- final NodeConnector destNc = edge.getHeadNodeConnector();
-
- final LinkBuilder it = new LinkBuilder().setKey(mapping.toTopologyLinkKey(edge));
-
- it.setSource(new SourceBuilder()
- .setSourceNode(mapping.toTopologyNodeKey(sourceNc.getNode()).getNodeId())
- .setSourceTp(mapping.toTopologyTerminationPointKey(sourceNc).getTpId())
- .build());
-
- it.setDestination(new DestinationBuilder()
- .setDestNode(mapping.toTopologyNodeKey(destNc.getNode()).getNodeId())
- .setDestTp(mapping.toTopologyTerminationPointKey(destNc).getTpId())
- .build());
-
- return it.build();
- }
-
- private Node constructNode(final org.opendaylight.controller.sal.core.Node node) {
- final Set<NodeConnector> connectors = getSwitchManager().getNodeConnectors(node);
- final ArrayList<TerminationPoint> tpList = new ArrayList<TerminationPoint>(connectors.size());
- for (final NodeConnector connector : connectors) {
- tpList.add(constructTerminationPoint(connector));
- }
-
- return new NodeBuilder()
- .setKey(mapping.toTopologyNodeKey(node))
- .setTerminationPoint(tpList)
- .build();
- }
-
- private TerminationPoint constructTerminationPoint(final NodeConnector connector) {
- return new TerminationPointBuilder().setKey(mapping.toTopologyTerminationPointKey(connector)).build();
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.topologymanager;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.Destination;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.Source;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class AdSalTopologyMapping {
- private final InstanceIdentifier<Topology> topologyPath;
-
- public AdSalTopologyMapping(final TopologyKey topology) {
- this.topologyPath = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, topology).toInstance();
- }
-
- public InstanceIdentifier<Topology> getTopologyPath() {
- return topologyPath;
- }
-
- public InstanceIdentifier<TerminationPoint> toTerminationPoint(final NodeConnector connector) {
- return getTopologyPath().builder()
- .child(Node.class)
- .child(TerminationPoint.class, toTerminationPointKey(connector))
- .toInstance();
- }
-
- public Map<Edge,Set<Property>> toEdgePropertiesMap(final Iterable<Link> links) {
- final HashMap<Edge,Set<Property>> ret = new HashMap<>();
- for (final Link link : links) {
- try {
- ret.put(toEdge(link), toProperties(link));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create edge properties for {}", link), e);
- }
- }
- return ret;
- }
-
- public static Set<Edge> toEdges(final Iterable<Link> links) throws ConstructionException {
- final HashSet<Edge> ret = new HashSet<Edge>();
- for (final Link link : links) {
- ret.add(toEdge(link));
- }
- return ret;
- }
-
- public static Edge toEdge(final Link link) throws ConstructionException {
- final NodeConnector tail = toNodeConnector(link.getSource());
- final NodeConnector head = toNodeConnector(link.getDestination());
- return new Edge(tail, head);
- }
-
- public static org.opendaylight.controller.sal.core.Node toAdNode(final Node node) throws ConstructionException {
- return toAdNode(node.getNodeId());
- }
-
- public static org.opendaylight.controller.sal.core.Node toAdNode(final NodeId node) throws ConstructionException {
- final NodeKey key = new NodeKey(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(node));
- return new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, key);
- }
-
- public static NodeConnector toNodeConnector(final Source ref) throws ConstructionException {
- final org.opendaylight.controller.sal.core.Node adNode = toAdNode(ref.getSourceNode());
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(ref.getSourceTp()));
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, adNode);
- }
-
- public static NodeConnector toNodeConnector(final Destination ref) throws ConstructionException {
- final org.opendaylight.controller.sal.core.Node adNode = toAdNode(ref.getDestNode());
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(ref.getDestTp()));
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, adNode);
- }
-
- public TerminationPointKey toTerminationPointKey(final NodeConnector connector) {
- return null;
- }
-
- public Set<Property> toProperties(final Link link) {
- return null;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.topologymanager;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.md.sal.binding.util.TypeSafeDataReader;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.Host;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.UpdateType;
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
-
-@SuppressWarnings("all")
-public class CompatibleTopologyManager extends ConfigurableLinkManager implements ITopologyManager {
- private AdSalTopologyMapping topologyMapping;
- private TypeSafeDataReader dataReader;
-
- public TypeSafeDataReader getDataReader() {
- return dataReader;
- }
-
- public void setDataReader(final TypeSafeDataReader dataReader) {
- this.dataReader = dataReader;
- }
-
- public AdSalTopologyMapping getTopologyMapping() {
- return topologyMapping;
- }
-
- public void setTopologyMapping(final AdSalTopologyMapping topologyMapping) {
- this.topologyMapping = topologyMapping;
- }
-
- @Override
- public Map<Edge,Set<Property>> getEdges() {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- return this.topologyMapping.toEdgePropertiesMap(topology.getLink());
- }
-
- @Override
- public Map<org.opendaylight.controller.sal.core.Node, Set<Edge>> getNodeEdges() {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- final HashMap<org.opendaylight.controller.sal.core.Node, Set<Edge>> ret = new HashMap<>();
- for (final Node node : topology.getNode()) {
- try {
- ret.put(topologyMapping.toAdNode(node), topologyMapping.toEdges(
- FluentIterable.from(topology.getLink()).filter(new Predicate<Link>() {
- @Override
- public boolean apply(final Link input) {
- final NodeId nodeId = node.getNodeId();
- if (nodeId.equals(input.getSource().getSourceNode())) {
- return true;
- }
- if (nodeId.equals(input.getDestination().getDestNode())) {
- return true;
- }
-
- return false;
- }
- })));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to construct node for {}", node), e);
- }
- }
- return ret;
- }
-
- /**
- * Returns true if point is connected to link
- */
- private boolean isInternal(final TerminationPoint point) {
- final Topology topology = getDataReader().readConfigurationData(topologyMapping.getTopologyPath());
- final TpId tpId = point.getKey().getTpId();
- return FluentIterable.from(topology.getLink()).anyMatch(new Predicate<Link>() {
- @Override
- public boolean apply(final Link input) {
- if (tpId.equals(input.getSource().getSourceTp())) {
- return true;
- }
- if (tpId.equals(input.getDestination().getDestTp())) {
- return true;
- }
- return false;
- }
- });
- }
-
- @Override
- public Set<NodeConnector> getNodeConnectorWithHost() {
- return null;
- }
-
- @Override
- public Host getHostAttachedToNodeConnector(final NodeConnector p) {
- final InstanceIdentifier<TerminationPoint> tpPath = topologyMapping.toTerminationPoint(p);
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public List<Host> getHostsAttachedToNodeConnector(final NodeConnector p) {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- throw new UnsupportedOperationException("Hosts not mapped yet");
- }
-
- @Override
- public Map<org.opendaylight.controller.sal.core.Node, Set<NodeConnector>> getNodesWithNodeConnectorHost() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public boolean isInternal(final NodeConnector p) {
- final TerminationPoint connector = getDataReader()
- .readConfigurationData(topologyMapping.toTerminationPoint(p));
- return this.isInternal(connector);
- }
-
- @Override
- public void updateHostLink(final NodeConnector p, final Host h, final UpdateType t, final Set<Property> props) {
- // Update app defined topology
- }
-
- @Override
- public Status saveConfig() {
- // FIXME: commit configuration
- return null;
- }
-}
+++ /dev/null
-/**
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.compatibility.topologymanager;
-
-import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
-
-public abstract class ConfigurableLinkManager implements ITopologyManager {
- @Override
- public final Status addUserLink(final TopologyUserLinkConfig link) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status deleteUserLink(final String linkName) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final ConcurrentMap<String,TopologyUserLinkConfig> getUserLinks() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-}
<modules>
<module>sal-compatibility</module>
- <module>inventory-topology-compatibility</module>
- <module>flow-management-compatibility</module>
</modules>
<dependencies>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
<!--InMemory DOM DataStore-->
<module>sal-inmemory-datastore</module>
- <!--sal-protocolbuffer-encoding-->
- <module>sal-protocolbuffer-encoding</module>
+ <!--sal-protocolbuffer-encoding is now part of sal-clutering-commons-->
+ <module>sal-clustering-commons</module>
<!-- sal-distributed-datastore -->
<module>sal-distributed-datastore</module>
<type>test-jar</type>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
+++ /dev/null
-/*
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.sal.binding.test.bugfix;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-
-@SuppressWarnings("deprecation")
-public class DOMCodecBug01Test extends AbstractDataServiceTest {
-
- private static final long FLOW_ID = 1234;
- private static final String NODE_ID = "node:1";
-
- private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
-
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
- .child(Node.class, NODE_KEY).toInstance();
-
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
- private static final FlowKey FLOW_KEY = new FlowKey(FLOW_ID, NODE_REF);
-
- private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(Flows.class) //
- .child(Flow.class, FLOW_KEY) //
- .toInstance();
-
-
-
- /**
- *
- * Testcase for https://bugs.opendaylight.org/show_bug.cgi?id=
- *
- * Cannot compile CoDec for
- * org.opendaylight.yang.gen.v1.urn.opendaylight.flow
- * .config.rev130819.flows.Flow
- *
- * When invoking following code in the consumer, user got an
- * IllegalStateException during creation of mapping between Java DTOs and
- * data-dom.
- *
- * Exception was compilation error which was caused by incorect generation
- * of code.
- *
- * Reported by Depthi V V
- *
- * @deprecated This test tests indirect generation, which should be tested
- * different way. the test creates conflicting transactions
- * and assumes correct commit - to test codec generation
- *
- */
- @Test
- @Ignore
- @Deprecated
- public void testIndirectGeneration() throws Exception {
-
- ExecutorService basePool = Executors.newFixedThreadPool(2);
- ListeningExecutorService listenablePool = MoreExecutors.listeningDecorator(basePool);
-
- createFlow();
-
- Object lock = new Object();
- CreateFlowTask task1 = new CreateFlowTask(lock);
- CreateFlowTask task2 = new CreateFlowTask(lock);
- CreateFlowTask task3 = new CreateFlowTask(lock);
-
- ListenableFuture<Void> task1Future = listenablePool.submit(task1);
- ListenableFuture<Void> task2Future = listenablePool.submit(task2);
- ListenableFuture<Void> task3Future = listenablePool.submit(task3);
-
-
- @SuppressWarnings("unchecked")
- ListenableFuture<List<Void>> compositeFuture = Futures.allAsList(task1Future,task2Future,task3Future);
-
- Thread.sleep(500);
- //lock.notifyAll();
- compositeFuture.get();
-
- verifyDataAreStoredProperly();
-
- DataModificationTransaction modification2 = baDataService.beginTransaction();
- modification2.removeConfigurationData(FLOW_INSTANCE_ID_BA);
-
- DataObject originalData = modification2.getOriginalConfigurationData().get(FLOW_INSTANCE_ID_BA);
- assertNotNull(originalData);
- RpcResult<TransactionStatus> ret2 = modification2.commit().get();
-
- assertNotNull(ret2);
- assertEquals(TransactionStatus.COMMITED, ret2.getResult());
-
- // Data are not in the store.
- assertNull(baDataService.readConfigurationData(FLOW_INSTANCE_ID_BA));
-
- }
-
- private void createFlow() throws Exception {
-
- DataModificationTransaction modification = baDataService.beginTransaction();
-
- FlowBuilder flow = new FlowBuilder();
- MatchBuilder match = new MatchBuilder();
- VlanMatchBuilder vlanBuilder = new VlanMatchBuilder();
- VlanIdBuilder vlanIdBuilder = new VlanIdBuilder();
- VlanId vlanId = new VlanId(10);
- vlanBuilder.setVlanId(vlanIdBuilder.setVlanId(vlanId).build());
- match.setVlanMatch(vlanBuilder.build());
-
- flow.setKey(FLOW_KEY);
- flow.setMatch(match.build());
- flow.setNode(NODE_REF);
- InstructionsBuilder instructions = new InstructionsBuilder();
- InstructionBuilder instruction = new InstructionBuilder();
-
- instruction.setOrder(10);
- ApplyActionsBuilder applyActions = new ApplyActionsBuilder();
- List<Action> actionList = new ArrayList<>();
- PopMplsActionBuilder popMplsAction = new PopMplsActionBuilder();
- popMplsAction.setEthernetType(34);
- actionList.add(new ActionBuilder().setAction(new PopMplsActionCaseBuilder().setPopMplsAction(popMplsAction.build()).build()).setOrder(10).build());
-
- applyActions.setAction(actionList );
-
- instruction.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(applyActions.build()).build());
-
-
- List<Instruction> instructionList = Collections.<Instruction>singletonList(instruction.build());
- instructions.setInstruction(instructionList );
-
- flow.setInstructions(instructions.build());
- modification.putConfigurationData(FLOW_INSTANCE_ID_BA, flow.build());
- RpcResult<TransactionStatus> ret = modification.commit().get();
- assertNotNull(ret);
- assertEquals(TransactionStatus.COMMITED, ret.getResult());
- }
-
- private void createFlow2() throws Exception {
- DataModificationTransaction modification = baDataService.beginTransaction();
- long id = 123;
- FlowKey key = new FlowKey(id, new NodeRef(NODE_INSTANCE_ID_BA));
- InstanceIdentifier<?> path1;
- FlowBuilder flow = new FlowBuilder();
- flow.setKey(key);
- MatchBuilder match = new MatchBuilder();
- match.setLayer4Match(new TcpMatchBuilder().build());
- flow.setMatch(match.build());
-
- path1 = InstanceIdentifier.builder(Flows.class).child(Flow.class, key).toInstance();
- // DataObject cls = (DataObject) modification.readConfigurationData(path1);
- modification.putConfigurationData(path1, flow.build());
- modification.commit();
-
- }
-
- private class CreateFlowTask implements Callable<Void> {
-
- public CreateFlowTask(final Object startSync) {
- }
-
- @Override
- public Void call() {
- try {
- //startSyncObj ect.wait();
- //Thread.sleep(500);
- createFlow();
- createFlow2();
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- return null;
- }
- }
-
- private void verifyDataAreStoredProperly() {
- CompositeNode biFlows = biDataService.readConfigurationData(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.of(Flows.QNAME));
- assertNotNull(biFlows);
- CompositeNode biFlow = biFlows.getFirstCompositeByName(Flow.QNAME);
- assertNotNull(biFlow);
- }
-
-
-}
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <scope>provided</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
<version>1.1-SNAPSHOT</version>
</parent>
- <artifactId>sal-protocolbuffer-encoding</artifactId>
+ <artifactId>sal-clustering-commons</artifactId>
<packaging>bundle</packaging>
# org.opendaylight.controller.protobuff.messages to properly exclude from sonar.
########################################################################################################
-protoc --proto_path=src/main/resources --java_out=src/main/java src/main/resources/*.proto
+protoc --proto_path=src/main/resources --proto_path=../sal-akka-raft/src/main/resources --java_out=src/main/java src/main/resources/*.proto
echo "Done generating Java source files."
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: CompositeModificationPayload.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Cohort.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Common.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: SimpleNormalizedNode.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: DataChangeListener.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Persistent.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ListenerRegistration.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardManager.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardTransactionChain.proto
-/*
- *
- * Copyright (c) 2014 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardTransaction.proto
*/
com.google.protobuf.ByteString
getTransactionIdBytes();
+
+ // required int32 transactionType = 2;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ boolean hasTransactionType();
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ int getTransactionType();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransaction}
transactionId_ = input.readBytes();
break;
}
+ case 16: {
+ bitField0_ |= 0x00000002;
+ transactionType_ = input.readInt32();
+ break;
+ }
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
}
}
+ // required int32 transactionType = 2;
+ public static final int TRANSACTIONTYPE_FIELD_NUMBER = 2;
+ private int transactionType_;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public boolean hasTransactionType() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public int getTransactionType() {
+ return transactionType_;
+ }
+
private void initFields() {
transactionId_ = "";
+ transactionType_ = 0;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
memoizedIsInitialized = 0;
return false;
}
+ if (!hasTransactionType()) {
+ memoizedIsInitialized = 0;
+ return false;
+ }
memoizedIsInitialized = 1;
return true;
}
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getTransactionIdBytes());
}
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeInt32(2, transactionType_);
+ }
getUnknownFields().writeTo(output);
}
size += com.google.protobuf.CodedOutputStream
.computeBytesSize(1, getTransactionIdBytes());
}
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt32Size(2, transactionType_);
+ }
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
return size;
super.clear();
transactionId_ = "";
bitField0_ = (bitField0_ & ~0x00000001);
+ transactionType_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
to_bitField0_ |= 0x00000001;
}
result.transactionId_ = transactionId_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.transactionType_ = transactionType_;
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
transactionId_ = other.transactionId_;
onChanged();
}
+ if (other.hasTransactionType()) {
+ setTransactionType(other.getTransactionType());
+ }
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return false;
}
+ if (!hasTransactionType()) {
+
+ return false;
+ }
return true;
}
return this;
}
+ // required int32 transactionType = 2;
+ private int transactionType_ ;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public boolean hasTransactionType() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public int getTransactionType() {
+ return transactionType_;
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public Builder setTransactionType(int value) {
+ bitField0_ |= 0x00000002;
+ transactionType_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public Builder clearTransactionType() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ transactionType_ = 0;
+ onChanged();
+ return this;
+ }
+
// @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransaction)
}
java.lang.String[] descriptorData = {
"\n\026ShardTransaction.proto\022!org.opendaylig" +
"ht.controller.mdsal\032\014Common.proto\"\022\n\020Clo" +
- "seTransaction\"\027\n\025CloseTransactionReply\"*" +
+ "seTransaction\"\027\n\025CloseTransactionReply\"C" +
"\n\021CreateTransaction\022\025\n\rtransactionId\030\001 \002" +
- "(\t\"M\n\026CreateTransactionReply\022\034\n\024transact" +
- "ionActorPath\030\001 \002(\t\022\025\n\rtransactionId\030\002 \002(" +
- "\t\"\022\n\020ReadyTransaction\"*\n\025ReadyTransactio" +
- "nReply\022\021\n\tactorPath\030\001 \002(\t\"l\n\nDeleteData\022" +
- "^\n\037instanceIdentifierPathArguments\030\001 \002(\013" +
- "25.org.opendaylight.controller.mdsal.Ins",
- "tanceIdentifier\"\021\n\017DeleteDataReply\"j\n\010Re" +
- "adData\022^\n\037instanceIdentifierPathArgument" +
- "s\030\001 \002(\01325.org.opendaylight.controller.md" +
- "sal.InstanceIdentifier\"P\n\rReadDataReply\022" +
- "?\n\016normalizedNode\030\001 \001(\0132\'.org.opendaylig" +
- "ht.controller.mdsal.Node\"\254\001\n\tWriteData\022^" +
- "\n\037instanceIdentifierPathArguments\030\001 \002(\0132" +
- "5.org.opendaylight.controller.mdsal.Inst" +
- "anceIdentifier\022?\n\016normalizedNode\030\002 \002(\0132\'" +
- ".org.opendaylight.controller.mdsal.Node\"",
- "\020\n\016WriteDataReply\"\254\001\n\tMergeData\022^\n\037insta" +
+ "(\t\022\027\n\017transactionType\030\002 \002(\005\"M\n\026CreateTra" +
+ "nsactionReply\022\034\n\024transactionActorPath\030\001 " +
+ "\002(\t\022\025\n\rtransactionId\030\002 \002(\t\"\022\n\020ReadyTrans" +
+ "action\"*\n\025ReadyTransactionReply\022\021\n\tactor" +
+ "Path\030\001 \002(\t\"l\n\nDeleteData\022^\n\037instanceIden" +
+ "tifierPathArguments\030\001 \002(\01325.org.opendayl",
+ "ight.controller.mdsal.InstanceIdentifier" +
+ "\"\021\n\017DeleteDataReply\"j\n\010ReadData\022^\n\037insta" +
"nceIdentifierPathArguments\030\001 \002(\01325.org.o" +
"pendaylight.controller.mdsal.InstanceIde" +
- "ntifier\022?\n\016normalizedNode\030\002 \002(\0132\'.org.op" +
- "endaylight.controller.mdsal.Node\"\020\n\016Merg" +
- "eDataReplyBV\n:org.opendaylight.controlle" +
- "r.protobuff.messages.transactionB\030ShardT" +
- "ransactionMessages"
+ "ntifier\"P\n\rReadDataReply\022?\n\016normalizedNo" +
+ "de\030\001 \001(\0132\'.org.opendaylight.controller.m" +
+ "dsal.Node\"\254\001\n\tWriteData\022^\n\037instanceIdent" +
+ "ifierPathArguments\030\001 \002(\01325.org.opendayli" +
+ "ght.controller.mdsal.InstanceIdentifier\022" +
+ "?\n\016normalizedNode\030\002 \002(\0132\'.org.opendaylig",
+ "ht.controller.mdsal.Node\"\020\n\016WriteDataRep" +
+ "ly\"\254\001\n\tMergeData\022^\n\037instanceIdentifierPa" +
+ "thArguments\030\001 \002(\01325.org.opendaylight.con" +
+ "troller.mdsal.InstanceIdentifier\022?\n\016norm" +
+ "alizedNode\030\002 \002(\0132\'.org.opendaylight.cont" +
+ "roller.mdsal.Node\"\020\n\016MergeDataReplyBV\n:o" +
+ "rg.opendaylight.controller.protobuff.mes" +
+ "sages.transactionB\030ShardTransactionMessa" +
+ "ges"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor,
- new java.lang.String[] { "TransactionId", });
+ new java.lang.String[] { "TransactionId", "TransactionType", });
internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor =
getDescriptor().getMessageTypes().get(3);
internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable = new
message CreateTransaction{
required string transactionId = 1;
+ required int32 transactionType =2;
}
message CreateTransactionReply{
--- /dev/null
+/*
+ * Copyright (c) 2014 Brocade Communications 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.md.sal.common.api.data;
+
+import org.opendaylight.yangtools.yang.common.RpcError;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+
+import com.google.common.base.Function;
+
+/**
+ * A type of TransactionCommitFailedException that indicates a situation that would result in a
+ * threading deadlock. This can occur if a caller that submits a write transaction tries to perform
+ * a blocking call via one of the <code>get</code> methods on the returned ListenableFuture. Callers
+ * should process the commit result asynchronously (via Futures#addCallback) to ensure deadlock
+ * won't occur.
+ *
+ * @author Thomas Pantelis
+ */
+public class TransactionCommitDeadlockException extends TransactionCommitFailedException {
+
+ private static final long serialVersionUID = 1L;
+
+ private static final String DEADLOCK_MESSAGE =
+ "An attempt to block on a ListenableFuture via a get method from a write " +
+ "transaction submit was detected that would result in deadlock. The commit " +
+ "result must be obtained asynchronously, e.g. via Futures#addCallback, to avoid deadlock.";
+
+ public static Function<Void, Exception> DEADLOCK_EXECUTOR_FUNCTION = new Function<Void, Exception>() {
+ @Override
+ public Exception apply(Void notUsed) {
+ return new TransactionCommitDeadlockException( DEADLOCK_MESSAGE,
+ RpcResultBuilder.newError(ErrorType.APPLICATION, "lock-denied", DEADLOCK_MESSAGE));
+ }
+ };
+
+ public TransactionCommitDeadlockException(String message, final RpcError... errors) {
+ super(message, errors);
+ }
+}
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-protocolbuffer-encoding</artifactId>
+ <artifactId>sal-clustering-commons</artifactId>
<version>1.1-SNAPSHOT</version>
</dependency>
<Private-Package></Private-Package>
<Import-Package>!*snappy;!org.jboss.*;*</Import-Package>
<Embed-Dependency>
- sal-protocolbuffer-encoding;
+ sal-clustering-commons;
sal-akka-raft;
!sal*;
!*config-api*;
import akka.event.LoggingAdapter;
import akka.japi.Creator;
import akka.serialization.Serialization;
-
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardMBeanFactory;
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardStats;
import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
}
}
+ private ActorRef createTypedTransactionActor(CreateTransaction createTransaction,String transactionId){
+ if(createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newReadOnlyTransaction(), getSelf(), schemaContext), transactionId);
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_WRITE.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newReadWriteTransaction(), getSelf(), schemaContext), transactionId);
+
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.WRITE_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newWriteOnlyTransaction(), getSelf(), schemaContext), transactionId);
+ }else{
+ throw new IllegalArgumentException ("CreateTransaction message has unidentified transaction type="+createTransaction.getTransactionType()) ;
+ }
+ }
+
private void createTransaction(CreateTransaction createTransaction) {
- DOMStoreReadWriteTransaction transaction =
- store.newReadWriteTransaction();
+
String transactionId = "shard-" + createTransaction.getTransactionId();
LOG.info("Creating transaction : {} " , transactionId);
- ActorRef transactionActor = getContext().actorOf(
- ShardTransaction.props(transaction, getSelf(), schemaContext), transactionId);
+ ActorRef transactionActor = createTypedTransactionActor(createTransaction,transactionId);
getSender()
.tell(new CreateTransactionReply(Serialization.serializedActorPath(transactionActor), createTransaction.getTransactionId()).toSerializable(),
--- /dev/null
+/*
+ *
+ * Copyright (c) 2014 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ */
+
+package org.opendaylight.controller.cluster.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.ReadData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardReadTransaction extends ShardTransaction {
+ private final DOMStoreReadTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+
+ public ShardReadTransaction(DOMStoreReadTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(shardActor, schemaContext);
+ this.transaction = transaction;
+
+ }
+
+ public ShardReadTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readData(transaction,ReadData.fromSerializable(message));
+ } else {
+ super.handleReceive(message);
+ }
+ }
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+
+}
--- /dev/null
+/*
+ *
+ * Copyright (c) 2014 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ */
+
+package org.opendaylight.controller.cluster.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
+import org.opendaylight.controller.cluster.datastore.messages.MergeData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.WriteData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardReadWriteTransaction extends ShardTransaction {
+ private final DOMStoreReadWriteTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+ public ShardReadWriteTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ public ShardReadWriteTransaction(DOMStoreReadWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super( shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readData(transaction,ReadData.fromSerializable(message));
+ }else if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ writeData(transaction, WriteData.fromSerializable(message, schemaContext));
+ } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ mergeData(transaction, MergeData.fromSerializable(message, schemaContext));
+ } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ deleteData(transaction,DeleteData.fromSerizalizable(message));
+ } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readyTransaction(transaction,new ReadyTransaction());
+ }else {
+ super.handleReceive(message);
+ }
+ }
+
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+}
package org.opendaylight.controller.cluster.datastore;
import akka.actor.ActorRef;
-import akka.actor.PoisonPill;
import akka.actor.Props;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
-import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
import org.opendaylight.controller.cluster.datastore.messages.MergeData;
import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
import org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification;
import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
* <li> {@link org.opendaylight.controller.cluster.datastore.messages.CloseTransaction}
* </p>
*/
-public class ShardTransaction extends AbstractUntypedActor {
-
- private final ActorRef shardActor;
- private final SchemaContext schemaContext;
-
- // FIXME : see below
- // If transactionChain is not null then this transaction is part of a
- // transactionChain. Not really clear as to what that buys us
- private final DOMStoreTransactionChain transactionChain;
-
- private final DOMStoreReadWriteTransaction transaction;
-
- private final MutableCompositeModification modification =
- new MutableCompositeModification();
-
- private final LoggingAdapter log =
- Logging.getLogger(getContext().system(), this);
-
- public ShardTransaction(DOMStoreReadWriteTransaction transaction,
- ActorRef shardActor, SchemaContext schemaContext) {
- this(null, transaction, shardActor, schemaContext);
- }
-
- public ShardTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadWriteTransaction transaction,
- ActorRef shardActor, SchemaContext schemaContext) {
- this.transactionChain = transactionChain;
- this.transaction = transaction;
- this.shardActor = shardActor;
- this.schemaContext = schemaContext;
- }
-
-
-
- public static Props props(final DOMStoreReadWriteTransaction transaction,
- final ActorRef shardActor, final SchemaContext schemaContext) {
- return Props.create(new Creator<ShardTransaction>() {
-
- @Override
- public ShardTransaction create() throws Exception {
- return new ShardTransaction(transaction, shardActor, schemaContext);
- }
- });
- }
-
- public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadWriteTransaction transaction,
- final ActorRef shardActor, final SchemaContext schemaContext) {
- return Props.create(new Creator<ShardTransaction>() {
-
- @Override
- public ShardTransaction create() throws Exception {
- return new ShardTransaction(transactionChain, transaction, shardActor, schemaContext);
- }
- });
+public abstract class ShardTransaction extends AbstractUntypedActor {
+
+ private final ActorRef shardActor;
+ protected final SchemaContext schemaContext;
+
+ // FIXME : see below
+ // If transactionChain is not null then this transaction is part of a
+ // transactionChain. Not really clear as to what that buys us
+ private final DOMStoreTransactionChain transactionChain;
+
+
+ private final MutableCompositeModification modification =
+ new MutableCompositeModification();
+
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+
+ protected ShardTransaction(
+ ActorRef shardActor, SchemaContext schemaContext) {
+ this(null, shardActor, schemaContext);
+ }
+
+ protected ShardTransaction(DOMStoreTransactionChain transactionChain,
+ ActorRef shardActor, SchemaContext schemaContext) {
+ this.transactionChain = transactionChain;
+ //this.transaction = transaction;
+ this.shardActor = shardActor;
+ this.schemaContext = schemaContext;
+ }
+
+
+
+ public static Props props(final DOMStoreReadTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreReadWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadWriteTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadWriteTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+
+ public static Props props(final DOMStoreWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardWriteTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardWriteTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (message.getClass().equals(CloseTransaction.SERIALIZABLE_CLASS)) {
+ closeTransaction(new CloseTransaction());
+ } else if (message instanceof GetCompositedModification) {
+ // This is here for testing only
+ getSender().tell(new GetCompositeModificationReply(
+ new ImmutableCompositeModification(modification)), getSelf());
+ }else{
+ throw new Exception ("ShardTransaction:handleRecieve received an unknown message"+message);
}
-
-
- @Override
- public void handleReceive(Object message) throws Exception {
- if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- readData(ReadData.fromSerializable(message));
- } else if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- writeData(WriteData.fromSerializable(message, schemaContext));
- } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- mergeData(MergeData.fromSerializable(message, schemaContext));
- } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- deleteData(DeleteData.fromSerizalizable(message));
- } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
- readyTransaction(new ReadyTransaction());
- } else if (message.getClass().equals(CloseTransaction.SERIALIZABLE_CLASS)) {
- closeTransaction(new CloseTransaction());
- } else if (message instanceof GetCompositedModification) {
- // This is here for testing only
- getSender().tell(new GetCompositeModificationReply(
- new ImmutableCompositeModification(modification)), getSelf());
- }else{
- throw new Exception ("Shard:handleRecieve received an unknown message"+message);
+ }
+
+ abstract protected void closeTransaction(CloseTransaction message);
+
+ protected void readData(DOMStoreReadTransaction transaction,ReadData message) {
+ final ActorRef sender = getSender();
+ final ActorRef self = getSelf();
+ final YangInstanceIdentifier path = message.getPath();
+ final ListenableFuture<Optional<NormalizedNode<?, ?>>> future =
+ transaction.read(path);
+
+ future.addListener(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ Optional<NormalizedNode<?, ?>> optional = future.get();
+ if (optional.isPresent()) {
+ sender.tell(new ReadDataReply(schemaContext,optional.get()).toSerializable(), self);
+ } else {
+ sender.tell(new ReadDataReply(schemaContext,null).toSerializable(), self);
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ log.error(e,
+ "An exception happened when reading data from path : "
+ + path.toString());
}
- }
- private void readData(ReadData message) {
- final ActorRef sender = getSender();
- final ActorRef self = getSelf();
- final YangInstanceIdentifier path = message.getPath();
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> future =
- transaction.read(path);
-
- future.addListener(new Runnable() {
- @Override
- public void run() {
- try {
- Optional<NormalizedNode<?, ?>> optional = future.get();
- if (optional.isPresent()) {
- sender.tell(new ReadDataReply(schemaContext,optional.get()).toSerializable(), self);
- } else {
- sender.tell(new ReadDataReply(schemaContext,null).toSerializable(), self);
- }
- } catch (InterruptedException | ExecutionException e) {
- log.error(e,
- "An exception happened when reading data from path : "
- + path.toString());
- }
-
- }
- }, getContext().dispatcher());
- }
+ }
+ }, getContext().dispatcher());
+ }
- private void writeData(WriteData message) {
- modification.addModification(
- new WriteModification(message.getPath(), message.getData(),schemaContext));
- LOG.debug("writeData at path : " + message.getPath().toString());
- transaction.write(message.getPath(), message.getData());
- getSender().tell(new WriteDataReply().toSerializable(), getSelf());
- }
+ protected void writeData(DOMStoreWriteTransaction transaction, WriteData message) {
+ modification.addModification(
+ new WriteModification(message.getPath(), message.getData(),schemaContext));
+ LOG.debug("writeData at path : " + message.getPath().toString());
+ transaction.write(message.getPath(), message.getData());
+ getSender().tell(new WriteDataReply().toSerializable(), getSelf());
+ }
- private void mergeData(MergeData message) {
- modification.addModification(
- new MergeModification(message.getPath(), message.getData(), schemaContext));
- LOG.debug("mergeData at path : " + message.getPath().toString());
- transaction.merge(message.getPath(), message.getData());
- getSender().tell(new MergeDataReply().toSerializable(), getSelf());
- }
+ protected void mergeData(DOMStoreWriteTransaction transaction, MergeData message) {
+ modification.addModification(
+ new MergeModification(message.getPath(), message.getData(), schemaContext));
+ LOG.debug("mergeData at path : " + message.getPath().toString());
+ transaction.merge(message.getPath(), message.getData());
+ getSender().tell(new MergeDataReply().toSerializable(), getSelf());
+ }
- private void deleteData(DeleteData message) {
- modification.addModification(new DeleteModification(message.getPath()));
- transaction.delete(message.getPath());
- getSender().tell(new DeleteDataReply().toSerializable(), getSelf());
- }
+ protected void deleteData(DOMStoreWriteTransaction transaction, DeleteData message) {
+ modification.addModification(new DeleteModification(message.getPath()));
+ transaction.delete(message.getPath());
+ getSender().tell(new DeleteDataReply().toSerializable(), getSelf());
+ }
- private void readyTransaction(ReadyTransaction message) {
- DOMStoreThreePhaseCommitCohort cohort = transaction.ready();
- ActorRef cohortActor = getContext().actorOf(
- ThreePhaseCommitCohort.props(cohort, shardActor, modification), "cohort");
- getSender()
- .tell(new ReadyTransactionReply(cohortActor.path()).toSerializable(), getSelf());
+ protected void readyTransaction(DOMStoreWriteTransaction transaction, ReadyTransaction message) {
+ DOMStoreThreePhaseCommitCohort cohort = transaction.ready();
+ ActorRef cohortActor = getContext().actorOf(
+ ThreePhaseCommitCohort.props(cohort, shardActor, modification), "cohort");
+ getSender()
+ .tell(new ReadyTransactionReply(cohortActor.path()).toSerializable(), getSelf());
- }
-
- private void closeTransaction(CloseTransaction message) {
- transaction.close();
- getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
- getSelf().tell(PoisonPill.getInstance(), getSelf());
- }
+ }
- // These classes are in here for test purposes only
+ // These classes are in here for test purposes only
- static class GetCompositedModification {
+ static class GetCompositedModification {
- }
+ }
- static class GetCompositeModificationReply {
- private final CompositeModification modification;
+ static class GetCompositeModificationReply {
+ private final CompositeModification modification;
- GetCompositeModificationReply(CompositeModification modification) {
- this.modification = modification;
- }
+ GetCompositeModificationReply(CompositeModification modification) {
+ this.modification = modification;
+ }
- public CompositeModification getModification() {
- return modification;
- }
+ public CompositeModification getModification() {
+ return modification;
}
+ }
}
import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionChainReply;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
}
}
+ private ActorRef createTypedTransactionActor(CreateTransaction createTransaction,String transactionId){
+ if(createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newReadOnlyTransaction(), getSelf(), schemaContext), transactionId);
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_WRITE.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newReadWriteTransaction(), getSelf(), schemaContext), transactionId);
+
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.WRITE_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newWriteOnlyTransaction(), getSelf(), schemaContext), transactionId);
+ }else{
+ throw new IllegalArgumentException ("CreateTransaction message has unidentified transaction type="+createTransaction.getTransactionType()) ;
+ }
+ }
+
private void createTransaction(CreateTransaction createTransaction) {
- DOMStoreReadWriteTransaction transaction =
- chain.newReadWriteTransaction();
- ActorRef transactionActor = getContext().actorOf(ShardTransaction
- .props(chain, transaction, getContext().parent(), schemaContext), "shard-" + createTransaction.getTransactionId());
+
+ ActorRef transactionActor = createTypedTransactionActor(createTransaction, "shard-" + createTransaction.getTransactionId());
getSender()
.tell(new CreateTransactionReply(transactionActor.path().toString(),createTransaction.getTransactionId()).toSerializable(),
getSelf());
--- /dev/null
+/*
+ *
+ * Copyright (c) 2014 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ */
+
+package org.opendaylight.controller.cluster.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
+import org.opendaylight.controller.cluster.datastore.messages.MergeData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.WriteData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardWriteTransaction extends ShardTransaction {
+ private final DOMStoreWriteTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+ public ShardWriteTransaction(DOMStoreWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super( shardActor, schemaContext);
+ this.transaction = transaction;
+
+ }
+
+ public ShardWriteTransaction(DOMStoreTransactionChain transactionChain, DOMStoreWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ writeData(transaction, WriteData.fromSerializable(message, schemaContext));
+ } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ mergeData(transaction, MergeData.fromSerializable(message, schemaContext));
+ } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ deleteData(transaction,DeleteData.fromSerizalizable(message));
+ } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readyTransaction(transaction,new ReadyTransaction());
+ }else {
+ super.handleReceive(message);
+ }
+ }
+
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+}
try {
Object response = actorContext.executeShardOperation(shardName,
- new CreateTransaction(identifier).toSerializable(),
+ new CreateTransaction(identifier,this.transactionType.ordinal() ).toSerializable(),
ActorContext.ASK_DURATION);
if (response.getClass()
.equals(CreateTransactionReply.SERIALIZABLE_CLASS)) {
public class CreateTransaction implements SerializableMessage {
public static Class SERIALIZABLE_CLASS = ShardTransactionMessages.CreateTransaction.class;
private final String transactionId;
+ private final int transactionType;
- public CreateTransaction(String transactionId){
+ public CreateTransaction(String transactionId, int transactionType){
this.transactionId = transactionId;
+ this.transactionType = transactionType;
}
public String getTransactionId() {
return transactionId;
}
+ public int getTransactionType() { return transactionType;}
+
@Override
public Object toSerializable() {
- return ShardTransactionMessages.CreateTransaction.newBuilder().setTransactionId(transactionId).build();
+ return ShardTransactionMessages.CreateTransaction.newBuilder().setTransactionId(transactionId).setTransactionType(transactionType).build();
}
public static CreateTransaction fromSerializable(Object message){
- return new CreateTransaction(((ShardTransactionMessages.CreateTransaction)message).getTransactionId());
+ ShardTransactionMessages.CreateTransaction createTransaction = (ShardTransactionMessages.CreateTransaction)message;
+ return new CreateTransaction(createTransaction.getTransactionId(),createTransaction.getTransactionType() );
}
}
System.out.println("Successfully created transaction chain");
// 2. Create a Transaction on the TransactionChain
- transactionChain.tell(new CreateTransaction("txn-1").toSerializable(), getRef());
+ transactionChain.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.WRITE_ONLY.ordinal() ).toSerializable(), getRef());
final ActorSelection transaction =
new ExpectMsg<ActorSelection>("CreateTransactionReply") {
new UpdateSchemaContext(TestModel.createTestContext()),
getRef());
- subject.tell(new CreateTransaction("txn-1").toSerializable(),
+ subject.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.READ_ONLY.ordinal() ).toSerializable(),
getRef());
final String out = new ExpectMsg<String>("match hint") {
new Within(duration("1 seconds")) {
protected void run() {
- subject.tell(new CreateTransaction("txn-1").toSerializable(), getRef());
+ subject.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.READ_ONLY.ordinal() ).toSerializable(), getRef());
final String out = new ExpectMsg<String>("match hint") {
// do not put code outside this method, will run afterwards
import akka.actor.Props;
import akka.actor.Terminated;
import akka.testkit.JavaTestKit;
+import akka.testkit.TestActorRef;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
+import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, testSchemaContext);
+ ShardTransaction.props(store.newReadOnlyTransaction(), shard, testSchemaContext);
final ActorRef subject = getSystem().actorOf(props, "testReadData");
new Within(duration("1 seconds")) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, testSchemaContext);
+ ShardTransaction.props( store.newReadOnlyTransaction(), shard, testSchemaContext);
final ActorRef subject = getSystem().actorOf(props, "testReadDataWhenDataNotFound");
new Within(duration("1 seconds")) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props(store.newWriteOnlyTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testWriteData");
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props( store.newWriteOnlyTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testDeleteData");
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props( store.newReadWriteTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testReadyTransaction");
}};
}
+
+
+ @Test
+ public void testNegativePerformingWriteOperationOnReadTransaction() throws Exception {
+ try {
+
+ final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
+ final Props props =
+ ShardTransaction.props(store.newReadOnlyTransaction(), shard, TestModel.createTestContext());
+ final TestActorRef subject = TestActorRef.apply(props,getSystem());
+
+ subject.receive(new DeleteData(TestModel.TEST_PATH).toSerializable(), ActorRef.noSender());
+ Assert.assertFalse(true);
+
+
+ } catch (Exception cs) {
+ assertEquals(cs.getClass().getSimpleName(), Exception.class.getSimpleName());
+ assertTrue(cs.getMessage().startsWith("ShardTransaction:handleRecieve received an unknown message"));
+ }
+ }
}
import java.util.concurrent.Executors;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
import org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataBrokerImpl;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListeningExecutorService;
.<LogicalDatastoreType, DOMStore> builder().put(LogicalDatastoreType.OPERATIONAL, operStore)
.put(LogicalDatastoreType.CONFIGURATION, configStore).build();
- DOMDataBrokerImpl newDataBroker = new DOMDataBrokerImpl(datastores, MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()));
+ DOMDataBrokerImpl newDataBroker = new DOMDataBrokerImpl(datastores,
+ new DeadlockDetectingListeningExecutorService(Executors.newSingleThreadExecutor(),
+ TransactionCommitDeadlockException.DEADLOCK_EXECUTOR_FUNCTION));
return newDataBroker;
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
private SchemaContext schemaContext;
private DOMDataBrokerImpl domBroker;
+ private ListeningExecutorService executor;
@Before
public void setupStore() {
.put(OPERATIONAL, operStore) //
.build();
- ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
+ executor = new DeadlockDetectingListeningExecutorService(Executors.newSingleThreadExecutor(),
+ TransactionCommitDeadlockException.DEADLOCK_EXECUTOR_FUNCTION);
domBroker = new DOMDataBrokerImpl(stores, executor);
}
- @Test
+ @After
+ public void tearDown() {
+ if( executor != null ) {
+ executor.shutdownNow();
+ }
+ }
+
+ @Test(timeout=10000)
public void testTransactionIsolation() throws InterruptedException, ExecutionException {
assertNotNull(domBroker);
assertFalse(readTxContainer.get().isPresent());
}
- @Test
+ @Test(timeout=10000)
public void testTransactionCommit() throws InterruptedException, ExecutionException {
DOMDataReadWriteTransaction writeTx = domBroker.newReadWriteTransaction();
assertTrue(afterCommitRead.isPresent());
}
+ /**
+ * Tests a simple DataChangeListener notification after a write.
+ */
+ @Test
+ public void testDataChangeListener() throws Throwable {
+
+ final NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode( TestModel.TEST_QNAME );
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener();
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, testNode );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+
+ dcListener.waitForChange();
+
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ NormalizedNode<?, ?> actualNode = dcListener.change.getCreatedData().get( TestModel.TEST_PATH );
+ assertEquals( "Created node", testNode, actualNode );
+ }
+
+ /**
+ * Tests a DataChangeListener that does an async submit of a write Tx in its onDataChanged method.
+ * This should succeed without deadlock.
+ */
+ @Test
+ public void testDataChangeListenerDoingAsyncWriteTxSubmit() throws Throwable {
+
+ final AtomicReference<Throwable> caughtCommitEx = new AtomicReference<>();
+ final CountDownLatch commitCompletedLatch = new CountDownLatch( 1 );
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener() {
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+
+ DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ writeTx.put( OPERATIONAL, TestModel.TEST2_PATH,
+ ImmutableNodes.containerNode( TestModel.TEST2_QNAME ) );
+ Futures.addCallback( writeTx.submit(), new FutureCallback<Void>() {
+ @Override
+ public void onSuccess( Void result ) {
+ commitCompletedLatch.countDown();
+ }
+
+ @Override
+ public void onFailure( Throwable t ) {
+ caughtCommitEx.set( t );
+ commitCompletedLatch.countDown();
+ }
+ } );
+
+ super.onDataChanged( change );
+ }
+ };
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+
+ dcListener.waitForChange();
+
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ assertTrue( "Commit Future was not invoked", commitCompletedLatch.await( 5, TimeUnit.SECONDS ) );
+
+ if( caughtCommitEx.get() != null ) {
+ throw caughtCommitEx.get();
+ }
+ }
+
+ /**
+ * Tests a DataChangeListener that does a blocking submit of a write Tx in its onDataChanged method.
+ * This should throw an exception and not deadlock.
+ */
+ @Test(expected=TransactionCommitDeadlockException.class)
+ public void testDataChangeListenerDoingBlockingWriteTxSubmit() throws Throwable {
+
+ final AtomicReference<Throwable> caughtCommitEx = new AtomicReference<>();
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener() {
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+ DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ writeTx.put( OPERATIONAL, TestModel.TEST2_PATH,
+ ImmutableNodes.containerNode( TestModel.TEST2_QNAME ) );
+ try {
+ writeTx.submit().get();
+ } catch( ExecutionException e ) {
+ caughtCommitEx.set( e.getCause() );
+ } catch( Exception e ) {
+ caughtCommitEx.set( e );
+ }
+ finally {
+ super.onDataChanged( change );
+ }
+ }
+ };
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+ dcListener.waitForChange();
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ if( caughtCommitEx.get() != null ) {
+ throw caughtCommitEx.get();
+ }
+ }
+
+ AtomicReference<Throwable> submitTxAsync( final DOMDataWriteTransaction writeTx ) {
+ final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
+ new Thread() {
+ @Override
+ public void run() {
+
+ try {
+ writeTx.submit();
+ } catch( Throwable e ) {
+ caughtEx.set( e );
+ }
+ }
+
+ }.start();
+
+ return caughtEx;
+ }
+
+ static class TestDOMDataChangeListener implements DOMDataChangeListener {
+
+ volatile AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change;
+ private final CountDownLatch latch = new CountDownLatch( 1 );
+
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+ this.change = change;
+ latch.countDown();
+ }
+
+ void waitForChange() throws InterruptedException {
+ assertTrue( "onDataChanged was not called", latch.await( 5, TimeUnit.SECONDS ) );
+ }
+ }
}
public static final QName TEST_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13",
"test");
+ public static final QName TEST2_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13",
+ "test2");
public static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list");
public static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list");
public static final QName OUTER_CHOICE_QNAME = QName.create(TEST_QNAME, "outer-choice");
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ public static final YangInstanceIdentifier TEST2_PATH = YangInstanceIdentifier.of(TEST2_QNAME);
public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME,"two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME,"three");
}
}
}
+
+ container test2 {
+ }
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
-import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.serializer.CnSnFromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
}
private CompositeNode datastoreNormalizedNodeToCompositeNode(final NormalizedNode<?, ?> dataNode, final DataSchemaNode schema) {
- Iterable<Node<?>> nodes = null;
+ Node<?> nodes = null;
if (dataNode == null) {
throw new RestconfDocumentedException(new RestconfError(ErrorType.APPLICATION, ErrorTag.DATA_MISSING,
"No data was found."));
}
- if (schema instanceof ContainerSchemaNode && dataNode instanceof ContainerNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getContainerNodeSerializer()
- .serialize((ContainerSchemaNode) schema, (ContainerNode) dataNode);
- } else if (schema instanceof ListSchemaNode && dataNode instanceof MapNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getMapNodeSerializer()
- .serialize((ListSchemaNode) schema, (MapNode) dataNode);
- } else if (schema instanceof ListSchemaNode && dataNode instanceof MapEntryNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getMapEntryNodeSerializer()
- .serialize((ListSchemaNode) schema, (MapEntryNode) dataNode);
- }
+ nodes = DataNormalizer.toLegacy(dataNode);
if (nodes != null) {
- if (nodes.iterator().hasNext()) {
- Node<?> nodeOldStruct = nodes.iterator().next();
- return (CompositeNode) nodeOldStruct;
+ if (nodes instanceof CompositeNode) {
+ return (CompositeNode) nodes;
} else {
LOG.error("The node " + dataNode.getNodeType() + " couldn't be transformed to compositenode.");
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
}
private NormalizedNode prepareCnDataForSlashesBehindMountPointTest() throws ParseException {
- CollectionNodeBuilder<MapEntryNode, MapNode> lst1 = ImmutableMapNodeBuilder.create();
- lst1.withNodeIdentifier(TestUtils.getNodeIdentifier("lst1", "test:module", "2014-01-09"));
- lst1.withChild(ImmutableMapEntryNodeBuilder
+ return ImmutableMapEntryNodeBuilder
.create()
.withNodeIdentifier(
TestUtils.getNodeIdentifierPredicate("lst1", "test:module", "2014-01-09", "lf11",
.withChild(
ImmutableLeafNodeBuilder.create()
.withNodeIdentifier(TestUtils.getNodeIdentifier("lf11", "test:module", "2014-01-09"))
- .withValue("GigabitEthernet0/0/0/0").build()).build());
+ .withValue("GigabitEthernet0/0/0/0").build()).build();
- return lst1.build();
}
/**
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
static NormalizedNode prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
String ietfInterfacesDate = "2013-07-04";
- CollectionNodeBuilder<MapEntryNode, MapNode> intface = ImmutableMapNodeBuilder.create();
String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
- intface.withNodeIdentifier(getNodeIdentifier("interface", namespace, ietfInterfacesDate));
DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode = ImmutableMapEntryNodeBuilder.create();
Map<String, Object> predicates = new HashMap<>();
.withNodeIdentifier(getNodeIdentifier("description", namespace, ietfInterfacesDate))
.withValue("some interface").build());
- intface.withChild(mapEntryNode.build());
-
- return intface.build();
+ return mapEntryNode.build();
}
}
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-base</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
LinkedHashMap<ConfigSnapshotHolder, EditAndCommitResponse> result = new LinkedHashMap<>();
// start pushing snapshots:
for (ConfigSnapshotHolder configSnapshotHolder : configs) {
- EditAndCommitResponse editAndCommitResponseWithRetries = pushConfigWithConflictingVersionRetries(configSnapshotHolder);
- logger.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
- result.put(configSnapshotHolder, editAndCommitResponseWithRetries);
+ if(configSnapshotHolder != null) {
+ EditAndCommitResponse editAndCommitResponseWithRetries = pushConfigWithConflictingVersionRetries(configSnapshotHolder);
+ logger.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
+ result.put(configSnapshotHolder, editAndCommitResponseWithRetries);
+ }
}
logger.debug("All configuration snapshots have been pushed successfully.");
return result;
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
- <!-- <version>0.6.2-SNAPSHOT</version>-->
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-json</artifactId>
- <version>0.6.2-SNAPSHOT</version>
+ <artifactId>yang-data-composite-node</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
-import org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
+import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
Code Review / controller.git / commitdiff