opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/service/AbstractDataTransaction.java

   1 /**
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.md.sal.common.impl.service;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.util.concurrent.AsyncFunction;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import java.util.concurrent.Future;
  16 import java.util.concurrent.TimeUnit;
  17 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  18 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  19 import org.opendaylight.controller.md.sal.common.impl.AbstractDataModification;
  20 import org.opendaylight.yangtools.concepts.Path;
  21 import org.opendaylight.yangtools.yang.common.RpcResult;
  22 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 @Deprecated
  27 public abstract class AbstractDataTransaction<P extends Path<P>, D extends Object> extends
  28         AbstractDataModification<P, D> {
  29     private static final Logger LOG = LoggerFactory.getLogger(AbstractDataTransaction.class);
  30     private static final ListenableFuture<RpcResult<TransactionStatus>> SUCCESS_FUTURE =
  31             Futures.immediateFuture(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
  32
  33     private final Object identifier;
  34     private final long allocationTime;
  35     private long readyTime = 0;
  36     private long completeTime = 0;
  37
  38     private TransactionStatus status = TransactionStatus.NEW;
  39
  40     private final AbstractDataBroker<P, D, ? extends Object> broker;
  41
  42     protected AbstractDataTransaction(final Object identifier,
  43             final AbstractDataBroker<P, D, ? extends Object> dataBroker) {
  44         super(dataBroker);
  45         this.identifier = Preconditions.checkNotNull(identifier);
  46         this.broker = Preconditions.checkNotNull(dataBroker);
  47         this.allocationTime = System.nanoTime();
  48         LOG.debug("Transaction {} Allocated.", identifier);
  49     }
  50
  51     @Override
  52     public Object getIdentifier() {
  53         return this.identifier;
  54     }
  55
  56     @Override
  57     public Future<RpcResult<TransactionStatus>> commit() {
  58         readyTime = System.nanoTime();
  59         if (LOG.isDebugEnabled()) {
  60             LOG.debug("Transaction {} Ready after {}ms.", identifier, TimeUnit.NANOSECONDS.toMillis(readyTime - allocationTime));
  61         }
  62         changeStatus(TransactionStatus.SUBMITED);
  63         return this.broker.commit(this);
  64     }
  65
  66     @Override
  67     public D readConfigurationData(final P path) {
  68         final D local = getUpdatedConfigurationData().get(path);
  69         if (local != null) {
  70             return local;
  71         }
  72         return this.broker.readConfigurationData(path);
  73     }
  74
  75     @Override
  76     public D readOperationalData(final P path) {
  77         final D local = this.getUpdatedOperationalData().get(path);
  78         if (local != null) {
  79             return local;
  80         }
  81         return this.broker.readOperationalData(path);
  82     }
  83
  84     @Override
  85     public int hashCode() {
  86         final int prime = 31;
  87         int result = 1;
  88         result = prime * result + ((identifier == null) ? 0 : identifier.hashCode());
  89         return result;
  90     }
  91
  92     @Override
  93     public boolean equals(final Object obj) {
  94         if (this == obj) {
  95             return true;
  96         }
  97         if (obj == null) {
  98             return false;
  99         }
 100         if (getClass() != obj.getClass()) {
 101             return false;
 102         }
 103         AbstractDataTransaction<?, ?> other = (AbstractDataTransaction<?, ?>) obj;
 104         if (identifier == null) {
 105             if (other.identifier != null) {
 106                 return false;
 107             }
 108         } else if (!identifier.equals(other.identifier)) {
 109             return false;
 110         }
 111         return true;
 112     }
 113
 114     @Override
 115     public TransactionStatus getStatus() {
 116         return this.status;
 117     }
 118
 119     protected abstract void onStatusChange(final TransactionStatus status);
 120
 121     public void succeeded() {
 122         this.completeTime = System.nanoTime();
 123         if (LOG.isDebugEnabled()) {
 124             LOG.debug("Transaction {} Committed after {}ms.", identifier, TimeUnit.NANOSECONDS.toMillis(completeTime - readyTime));
 125         }
 126         changeStatus(TransactionStatus.COMMITED);
 127     }
 128
 129     public void failed() {
 130         this.completeTime = System.nanoTime();
 131
 132         if (LOG.isDebugEnabled()) {
 133             LOG.debug("Transaction {} Failed after {}ms.", identifier, TimeUnit.NANOSECONDS.toMillis(completeTime - readyTime));
 134         }
 135         changeStatus(TransactionStatus.FAILED);
 136     }
 137
 138     private void changeStatus(final TransactionStatus status) {
 139         LOG.debug("Transaction {} transitioned from {} to {}", getIdentifier(), this.status, status);
 140         this.status = status;
 141         this.onStatusChange(status);
 142     }
 143
 144     public static ListenableFuture<RpcResult<TransactionStatus>> convertToLegacyCommitFuture(final CheckedFuture<Void,TransactionCommitFailedException> from) {
 145         return Futures.transform(from, new AsyncFunction<Void, RpcResult<TransactionStatus>>() {
 146             @Override
 147             public ListenableFuture<RpcResult<TransactionStatus>> apply(final Void input) {
 148                 return SUCCESS_FUTURE;
 149             }
 150         });
 151     }
 152 }