diff options
Diffstat (limited to 'infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write')
3 files changed, 97 insertions, 28 deletions
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java index 60a81a77a..22e30bd9e 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java @@ -16,20 +16,20 @@ package io.fd.honeycomb.translate.util.write; -import com.google.common.util.concurrent.CheckedFuture; +import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION; + +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.honeycomb.translate.write.Writer; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; import javax.annotation.Nullable; - -import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; /** * Simple DataBroker backed writer allowing to delegate writes to different brokers. @@ -55,11 +55,11 @@ public final class BindingBrokerWriter<D extends DataObject> implements Writer<D @Nonnull final WriteContext ctx) throws WriteFailedException { final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter); - final CheckedFuture<Void, TransactionCommitFailedException> result = writeTransaction.submit(); + final FluentFuture<? extends CommitInfo> result = writeTransaction.commit(); try { - result.checkedGet(); - } catch (TransactionCommitFailedException e) { - throw new WriteFailedException(id, e); + result.get(); + } catch (InterruptedException | ExecutionException ex) { + throw new WriteFailedException(id, ex); } } diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java new file mode 100644 index 000000000..f6c2f0ffa --- /dev/null +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2019 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.util.write; + +import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; + +import com.google.common.util.concurrent.FluentFuture; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.honeycomb.translate.write.Writer; +import java.util.concurrent.ExecutionException; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +/** + * Simple DataBroker backed writer allowing to delegate writes to different brokers. + */ +public final class LegacyBindingBrokerWriter<D extends DataObject> implements Writer<D> { + private final InstanceIdentifier<D> instanceIdentifier; + private final DataBroker dataBroker; + + public LegacyBindingBrokerWriter(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker) { + this.instanceIdentifier = instanceIdentifier; + this.dataBroker = dataBroker; + } + + @Nonnull + @Override + public InstanceIdentifier<D> getManagedDataObjectType() { + return instanceIdentifier; + } + + @Override + public void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id, + @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, + @Nonnull final WriteContext ctx) throws WriteFailedException { + final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); + writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter); + final FluentFuture<? extends CommitInfo> result = writeTransaction.commit(); + try { + result.get(); + } catch (InterruptedException | ExecutionException ex) { + throw new WriteFailedException(id, ex); + } + } + + @Override + public boolean supportsDirectUpdate() { + return false; + } +} diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java index e853d8632..d97b5b715 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java @@ -18,17 +18,17 @@ package io.fd.honeycomb.translate.util.write; import static com.google.common.base.Preconditions.checkState; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.write.WriteContext; import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -39,15 +39,15 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; */ public final class TransactionWriteContext implements WriteContext { - private final DOMDataReadOnlyTransaction beforeTx; - private final DOMDataReadOnlyTransaction afterTx; + private final DOMDataTreeReadTransaction beforeTx; + private final DOMDataTreeReadTransaction afterTx; private final ModificationCache ctx; private final BindingNormalizedNodeSerializer serializer; private final MappingContext mappingContext; public TransactionWriteContext(final BindingNormalizedNodeSerializer serializer, - final DOMDataReadOnlyTransaction beforeTx, - final DOMDataReadOnlyTransaction afterTx, + final DOMDataTreeReadTransaction beforeTx, + final DOMDataTreeReadTransaction afterTx, final MappingContext mappingContext) { this.serializer = serializer; this.beforeTx = beforeTx; @@ -70,18 +70,17 @@ public final class TransactionWriteContext implements WriteContext { private <T extends DataObject> Optional<T> read(final InstanceIdentifier<T> currentId, - final DOMDataReadOnlyTransaction tx) { + final DOMDataTreeReadTransaction tx) { final YangInstanceIdentifier path = serializer.toYangInstanceIdentifier(currentId); - final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read = - tx.read(LogicalDatastoreType.CONFIGURATION, path); + final FluentFuture<Optional<NormalizedNode<?, ?>>> read = tx.read(LogicalDatastoreType.CONFIGURATION, path); try { // TODO HONEYCOMB-169 once the APIs are asynchronous use just Futures.transform - final Optional<NormalizedNode<?, ?>> optional = read.checkedGet(); + final Optional<NormalizedNode<?, ?>> optional = read.get(); if (!optional.isPresent()) { - return Optional.absent(); + return Optional.empty(); } final NormalizedNode<?, ?> data = optional.get(); @@ -91,7 +90,7 @@ public final class TransactionWriteContext implements WriteContext { checkState(targetType.isAssignableFrom(entry.getValue().getClass()), "Unexpected data object type, should be: %s, but was: %s", targetType, entry.getValue().getClass()); return Optional.of(targetType.cast(entry.getValue())); - } catch (ReadFailedException e) { + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform read", e); } } |