*/
package org.opendaylight.controller.cluster.databroker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.FinalizablePhantomReference;
import com.google.common.base.FinalizableReferenceQueue;
-import com.google.common.base.Preconditions;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.databroker.actors.dds.AbstractClientHandle;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
-import org.opendaylight.controller.sal.core.spi.data.AbstractDOMStoreTransaction;
+import org.opendaylight.mdsal.dom.spi.store.AbstractDOMStoreTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(Finalizer.class);
private final AbstractClientHandle<?> transaction;
+ private final Throwable allocationContext;
- private Finalizer(final ClientBackedTransaction<?> referent, final AbstractClientHandle<?> transaction) {
+ private Finalizer(final ClientBackedTransaction<?> referent, final AbstractClientHandle<?> transaction,
+ final Throwable allocationContext) {
super(referent, QUEUE);
- this.transaction = Preconditions.checkNotNull(transaction);
+ this.transaction = requireNonNull(transaction);
+ this.allocationContext = allocationContext;
}
- static @Nonnull <T extends AbstractClientHandle<?>> T recordTransaction(
- @Nonnull final ClientBackedTransaction<T> referent, @Nonnull final T transaction) {
- FINALIZERS.add(new Finalizer(referent, transaction));
+ static <T extends AbstractClientHandle<?>> @NonNull T recordTransaction(
+ final @NonNull ClientBackedTransaction<T> referent, final @NonNull T transaction,
+ final @Nullable Throwable allocationContext) {
+ FINALIZERS.add(new Finalizer(referent, transaction, allocationContext));
return transaction;
}
public void finalizeReferent() {
FINALIZERS.remove(this);
if (transaction.abort()) {
- LOG.info("Aborted orphan transaction {}", transaction);
+ LOG.info("Aborted orphan transaction {}", transaction, allocationContext);
}
}
}
private final T delegate;
- ClientBackedTransaction(final T delegate) {
+ ClientBackedTransaction(final T delegate, final Throwable allocationContext) {
super(delegate.getIdentifier());
- this.delegate = Finalizer.recordTransaction(this, delegate);
+ this.delegate = Finalizer.recordTransaction(this, delegate, allocationContext);
}
final T delegate() {