Fix warnings/javadocs in sal-distributed-datastore
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / java / org / opendaylight / controller / cluster / datastore / RemoteTransactionContextSupport.java
1 /*
2  * Copyright (c) 2015 Brocade Communications Systems, Inc. and others.  All rights reserved.
3  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
4  *
5  * This program and the accompanying materials are made available under the
6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
7  * and is available at http://www.eclipse.org/legal/epl-v10.html
8  */
9 package org.opendaylight.controller.cluster.datastore;
10
11 import akka.actor.ActorSelection;
12 import akka.dispatch.OnComplete;
13 import akka.pattern.AskTimeoutException;
14 import akka.util.Timeout;
15 import com.google.common.base.Preconditions;
16 import java.util.concurrent.TimeUnit;
17 import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
18 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
19 import org.opendaylight.controller.cluster.datastore.exceptions.ShardLeaderNotRespondingException;
20 import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
21 import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
22 import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
23 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
24 import org.slf4j.Logger;
25 import org.slf4j.LoggerFactory;
26 import scala.concurrent.Future;
27 import scala.concurrent.duration.FiniteDuration;
28
29 /**
30  * Handles creation of TransactionContext instances for remote transactions. This class creates
31  * remote transactions, if necessary, by sending CreateTransaction messages with retries, up to a limit,
32  * if the shard doesn't have a leader yet. This is done by scheduling a retry task after a short delay.
33  * <p/>
34  * The end result from a completed CreateTransaction message is a TransactionContext that is
35  * used to perform transaction operations. Transaction operations that occur before the
36  * CreateTransaction completes are cache via a TransactionContextWrapper and executed once the
37  * CreateTransaction completes, successfully or not.
38  */
39 final class RemoteTransactionContextSupport {
40     private static final Logger LOG = LoggerFactory.getLogger(RemoteTransactionContextSupport.class);
41
42     private static final long CREATE_TX_TRY_INTERVAL_IN_MS = 1000;
43     private static final long MAX_CREATE_TX_MSG_TIMEOUT_IN_MS = 5000;
44
45     private final TransactionProxy parent;
46     private final String shardName;
47
48     /**
49      * The target primary shard.
50      */
51     private volatile PrimaryShardInfo primaryShardInfo;
52
53     /**
54      * The total timeout for creating a tx on the primary shard.
55      */
56     private volatile long totalCreateTxTimeout;
57
58     private final Timeout createTxMessageTimeout;
59
60     private final TransactionContextWrapper transactionContextWrapper;
61
62     RemoteTransactionContextSupport(final TransactionContextWrapper transactionContextWrapper,
63             final TransactionProxy parent, final String shardName) {
64         this.parent = Preconditions.checkNotNull(parent);
65         this.shardName = shardName;
66         this.transactionContextWrapper = transactionContextWrapper;
67
68         // For the total create tx timeout, use 2 times the election timeout. This should be enough time for
69         // a leader re-election to occur if we happen to hit it in transition.
70         totalCreateTxTimeout = parent.getActorContext().getDatastoreContext().getShardRaftConfig()
71                 .getElectionTimeOutInterval().toMillis() * 2;
72
73         // We'll use the operationTimeout for the the create Tx message timeout so it can be set appropriately
74         // for unit tests but cap it at MAX_CREATE_TX_MSG_TIMEOUT_IN_MS. The operationTimeout could be set
75         // larger than the totalCreateTxTimeout in production which we don't want.
76         long operationTimeout = parent.getActorContext().getOperationTimeout().duration().toMillis();
77         createTxMessageTimeout = new Timeout(Math.min(operationTimeout, MAX_CREATE_TX_MSG_TIMEOUT_IN_MS),
78                 TimeUnit.MILLISECONDS);
79     }
80
81     String getShardName() {
82         return shardName;
83     }
84
85     private TransactionType getTransactionType() {
86         return parent.getType();
87     }
88
89     private ActorContext getActorContext() {
90         return parent.getActorContext();
91     }
92
93     private TransactionIdentifier getIdentifier() {
94         return parent.getIdentifier();
95     }
96
97     /**
98      * Sets the target primary shard and initiates a CreateTransaction try.
99      */
100     void setPrimaryShard(PrimaryShardInfo primaryShardInfo) {
101         this.primaryShardInfo = primaryShardInfo;
102
103         if (getTransactionType() == TransactionType.WRITE_ONLY
104                 && getActorContext().getDatastoreContext().isWriteOnlyTransactionOptimizationsEnabled()) {
105             ActorSelection primaryShard = primaryShardInfo.getPrimaryShardActor();
106
107             LOG.debug("Tx {} Primary shard {} found - creating WRITE_ONLY transaction context",
108                 getIdentifier(), primaryShard);
109
110             // For write-only Tx's we prepare the transaction modifications directly on the shard actor
111             // to avoid the overhead of creating a separate transaction actor.
112             transactionContextWrapper.executePriorTransactionOperations(createValidTransactionContext(
113                     primaryShard, String.valueOf(primaryShard.path()), primaryShardInfo.getPrimaryShardVersion()));
114         } else {
115             tryCreateTransaction();
116         }
117     }
118
119     /**
120       Performs a CreateTransaction try async.
121      */
122     private void tryCreateTransaction() {
123         LOG.debug("Tx {} Primary shard {} found - trying create transaction", getIdentifier(),
124                 primaryShardInfo.getPrimaryShardActor());
125
126         Object serializedCreateMessage = new CreateTransaction(getIdentifier(), getTransactionType().ordinal(),
127                     primaryShardInfo.getPrimaryShardVersion()).toSerializable();
128
129         Future<Object> createTxFuture = getActorContext().executeOperationAsync(
130                 primaryShardInfo.getPrimaryShardActor(), serializedCreateMessage, createTxMessageTimeout);
131
132         createTxFuture.onComplete(new OnComplete<Object>() {
133             @Override
134             public void onComplete(Throwable failure, Object response) {
135                 onCreateTransactionComplete(failure, response);
136             }
137         }, getActorContext().getClientDispatcher());
138     }
139
140     private void tryFindPrimaryShard() {
141         LOG.debug("Tx {} Retrying findPrimaryShardAsync for shard {}", getIdentifier(), shardName);
142
143         this.primaryShardInfo = null;
144         Future<PrimaryShardInfo> findPrimaryFuture = getActorContext().findPrimaryShardAsync(shardName);
145         findPrimaryFuture.onComplete(new OnComplete<PrimaryShardInfo>() {
146             @Override
147             public void onComplete(final Throwable failure, final PrimaryShardInfo newPrimaryShardInfo) {
148                 onFindPrimaryShardComplete(failure, newPrimaryShardInfo);
149             }
150         }, getActorContext().getClientDispatcher());
151     }
152
153     private void onFindPrimaryShardComplete(final Throwable failure, final PrimaryShardInfo newPrimaryShardInfo) {
154         if (failure == null) {
155             this.primaryShardInfo = newPrimaryShardInfo;
156             tryCreateTransaction();
157         } else {
158             LOG.debug("Tx {}: Find primary for shard {} failed", getIdentifier(), shardName, failure);
159
160             onCreateTransactionComplete(failure, null);
161         }
162     }
163
164     private void onCreateTransactionComplete(Throwable failure, Object response) {
165         // An AskTimeoutException will occur if the local shard forwards to an unavailable remote leader or
166         // the cached remote leader actor is no longer available.
167         boolean retryCreateTransaction = primaryShardInfo != null
168                 && (failure instanceof NoShardLeaderException || failure instanceof AskTimeoutException);
169         if (retryCreateTransaction) {
170             // Schedule a retry unless we're out of retries. Note: totalCreateTxTimeout is volatile as it may
171             // be written by different threads however not concurrently, therefore decrementing it
172             // non-atomically here is ok.
173             if (totalCreateTxTimeout > 0) {
174                 long scheduleInterval = CREATE_TX_TRY_INTERVAL_IN_MS;
175                 if (failure instanceof AskTimeoutException) {
176                     // Since we use the createTxMessageTimeout for the CreateTransaction request and it timed
177                     // out, subtract it from the total timeout. Also since the createTxMessageTimeout period
178                     // has already elapsed, we can immediately schedule the retry (10 ms is virtually immediate).
179                     totalCreateTxTimeout -= createTxMessageTimeout.duration().toMillis();
180                     scheduleInterval = 10;
181                 }
182
183                 totalCreateTxTimeout -= scheduleInterval;
184
185                 LOG.debug("Tx {}: create tx on shard {} failed with exception \"{}\" - scheduling retry in {} ms",
186                         getIdentifier(), shardName, failure, scheduleInterval);
187
188                 getActorContext().getActorSystem().scheduler().scheduleOnce(
189                     FiniteDuration.create(scheduleInterval, TimeUnit.MILLISECONDS),
190                     () -> tryFindPrimaryShard(), getActorContext().getClientDispatcher());
191                 return;
192             }
193         }
194
195         createTransactionContext(failure, response);
196     }
197
198     private void createTransactionContext(Throwable failure, Object response) {
199         // Create the TransactionContext from the response or failure. Store the new
200         // TransactionContext locally until we've completed invoking the
201         // TransactionOperations. This avoids thread timing issues which could cause
202         // out-of-order TransactionOperations. Eg, on a modification operation, if the
203         // TransactionContext is non-null, then we directly call the TransactionContext.
204         // However, at the same time, the code may be executing the cached
205         // TransactionOperations. So to avoid thus timing, we don't publish the
206         // TransactionContext until after we've executed all cached TransactionOperations.
207         TransactionContext localTransactionContext;
208         if (failure != null) {
209             LOG.debug("Tx {} Creating NoOpTransaction because of error", getIdentifier(), failure);
210
211             Throwable resultingEx = failure;
212             if (failure instanceof AskTimeoutException) {
213                 resultingEx = new ShardLeaderNotRespondingException(String.format(
214                         "Could not create a %s transaction on shard %s. The shard leader isn't responding.",
215                         parent.getType(), shardName), failure);
216             } else if (!(failure instanceof NoShardLeaderException)) {
217                 resultingEx = new Exception(String.format(
218                     "Error creating %s transaction on shard %s", parent.getType(), shardName), failure);
219             }
220
221             localTransactionContext = new NoOpTransactionContext(resultingEx, getIdentifier());
222         } else if (CreateTransactionReply.isSerializedType(response)) {
223             localTransactionContext = createValidTransactionContext(
224                     CreateTransactionReply.fromSerializable(response));
225         } else {
226             IllegalArgumentException exception = new IllegalArgumentException(String.format(
227                     "Invalid reply type %s for CreateTransaction", response.getClass()));
228
229             localTransactionContext = new NoOpTransactionContext(exception, getIdentifier());
230         }
231
232         transactionContextWrapper.executePriorTransactionOperations(localTransactionContext);
233     }
234
235     private TransactionContext createValidTransactionContext(CreateTransactionReply reply) {
236         LOG.debug("Tx {} Received {}", getIdentifier(), reply);
237
238         return createValidTransactionContext(getActorContext().actorSelection(reply.getTransactionPath()),
239                 reply.getTransactionPath(), primaryShardInfo.getPrimaryShardVersion());
240     }
241
242     private TransactionContext createValidTransactionContext(ActorSelection transactionActor, String transactionPath,
243             short remoteTransactionVersion) {
244         final TransactionContext ret = new RemoteTransactionContext(transactionContextWrapper.getIdentifier(),
245                 transactionActor, getActorContext(), remoteTransactionVersion, transactionContextWrapper.getLimiter());
246
247         if (parent.getType() == TransactionType.READ_ONLY) {
248             TransactionContextCleanup.track(parent, ret);
249         }
250
251         return ret;
252     }
253 }
254

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.