Adjust to yangtools-2.0.0 changes
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / java / org / opendaylight / controller / cluster / datastore / FrontendReadWriteTransaction.java
1 /*
2  * Copyright (c) 2016 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.cluster.datastore;
9
10 import com.google.common.base.Optional;
11 import com.google.common.base.Preconditions;
12 import com.google.common.primitives.UnsignedLong;
13 import com.google.common.util.concurrent.FutureCallback;
14 import java.util.Collection;
15 import javax.annotation.Nullable;
16 import javax.annotation.concurrent.NotThreadSafe;
17 import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
18 import org.opendaylight.controller.cluster.access.commands.CommitLocalTransactionRequest;
19 import org.opendaylight.controller.cluster.access.commands.ExistsTransactionRequest;
20 import org.opendaylight.controller.cluster.access.commands.ExistsTransactionSuccess;
21 import org.opendaylight.controller.cluster.access.commands.ModifyTransactionRequest;
22 import org.opendaylight.controller.cluster.access.commands.ModifyTransactionSuccess;
23 import org.opendaylight.controller.cluster.access.commands.PersistenceProtocol;
24 import org.opendaylight.controller.cluster.access.commands.ReadTransactionRequest;
25 import org.opendaylight.controller.cluster.access.commands.ReadTransactionSuccess;
26 import org.opendaylight.controller.cluster.access.commands.TransactionAbortRequest;
27 import org.opendaylight.controller.cluster.access.commands.TransactionAbortSuccess;
28 import org.opendaylight.controller.cluster.access.commands.TransactionCanCommitSuccess;
29 import org.opendaylight.controller.cluster.access.commands.TransactionCommitSuccess;
30 import org.opendaylight.controller.cluster.access.commands.TransactionDelete;
31 import org.opendaylight.controller.cluster.access.commands.TransactionDoCommitRequest;
32 import org.opendaylight.controller.cluster.access.commands.TransactionMerge;
33 import org.opendaylight.controller.cluster.access.commands.TransactionModification;
34 import org.opendaylight.controller.cluster.access.commands.TransactionPreCommitRequest;
35 import org.opendaylight.controller.cluster.access.commands.TransactionPreCommitSuccess;
36 import org.opendaylight.controller.cluster.access.commands.TransactionRequest;
37 import org.opendaylight.controller.cluster.access.commands.TransactionSuccess;
38 import org.opendaylight.controller.cluster.access.commands.TransactionWrite;
39 import org.opendaylight.controller.cluster.access.concepts.RequestEnvelope;
40 import org.opendaylight.controller.cluster.access.concepts.RequestException;
41 import org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException;
42 import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
43 import org.opendaylight.controller.cluster.access.concepts.UnsupportedRequestException;
44 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
45 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
46 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
47 import org.slf4j.Logger;
48 import org.slf4j.LoggerFactory;
49
50 /**
51  * Frontend read-write transaction state as observed by the shard leader.
52  *
53  * @author Robert Varga
54  */
55 @NotThreadSafe
56 final class FrontendReadWriteTransaction extends FrontendTransaction {
57     private enum CommitStage {
58         READY,
59         CAN_COMMIT_PENDING,
60         CAN_COMMIT_COMPLETE,
61         PRE_COMMIT_PENDING,
62         PRE_COMMIT_COMPLETE,
63         COMMIT_PENDING,
64     }
65
66     private abstract static class State {
67         @Override
68         public abstract String toString();
69     }
70
71     private static final class Failed extends State {
72         final RequestException cause;
73
74         Failed(final RequestException cause) {
75             this.cause = Preconditions.checkNotNull(cause);
76         }
77
78         @Override
79         public String toString() {
80             return "FAILED (" + cause.getMessage() + ")";
81         }
82     }
83
84     private static final class Open extends State {
85         final ReadWriteShardDataTreeTransaction openTransaction;
86
87         Open(final ReadWriteShardDataTreeTransaction openTransaction) {
88             this.openTransaction = Preconditions.checkNotNull(openTransaction);
89         }
90
91         @Override
92         public String toString() {
93             return "OPEN";
94         }
95     }
96
97     private static final class Ready extends State {
98         final ShardDataTreeCohort readyCohort;
99         CommitStage stage;
100
101         Ready(final ShardDataTreeCohort readyCohort) {
102             this.readyCohort = Preconditions.checkNotNull(readyCohort);
103             this.stage = CommitStage.READY;
104         }
105
106         @Override
107         public String toString() {
108             return "READY (" + stage + ")";
109         }
110     }
111
112     private static final class Sealed extends State {
113         final DataTreeModification sealedModification;
114
115         Sealed(final DataTreeModification sealedModification) {
116             this.sealedModification = Preconditions.checkNotNull(sealedModification);
117         }
118
119         @Override
120         public String toString() {
121             return "SEALED";
122         }
123     }
124
125     /**
126      * Retired state, needed to catch and suppress callbacks after we have removed associated state.
127      */
128     private static final class Retired extends State {
129         private final String prevStateString;
130
131         Retired(final State prevState) {
132             prevStateString = prevState.toString();
133         }
134
135         @Override
136         public String toString() {
137             return "RETIRED (in " + prevStateString + ")";
138         }
139     }
140
141     private static final Logger LOG = LoggerFactory.getLogger(FrontendReadWriteTransaction.class);
142     private static final State ABORTED = new State() {
143         @Override
144         public String toString() {
145             return "ABORTED";
146         }
147     };
148     private static final State ABORTING = new State() {
149         @Override
150         public String toString() {
151             return "ABORTING";
152         }
153     };
154     private static final State COMMITTED = new State() {
155         @Override
156         public String toString() {
157             return "COMMITTED";
158         }
159     };
160
161     private State state;
162
163     private FrontendReadWriteTransaction(final AbstractFrontendHistory history, final TransactionIdentifier id,
164             final ReadWriteShardDataTreeTransaction transaction) {
165         super(history, id);
166         this.state = new Open(transaction);
167     }
168
169     private FrontendReadWriteTransaction(final AbstractFrontendHistory history, final TransactionIdentifier id,
170             final DataTreeModification mod) {
171         super(history, id);
172         this.state = new Sealed(mod);
173     }
174
175     static FrontendReadWriteTransaction createOpen(final AbstractFrontendHistory history,
176             final ReadWriteShardDataTreeTransaction transaction) {
177         return new FrontendReadWriteTransaction(history, transaction.getIdentifier(), transaction);
178     }
179
180     static FrontendReadWriteTransaction createReady(final AbstractFrontendHistory history,
181             final TransactionIdentifier id, final DataTreeModification mod) {
182         return new FrontendReadWriteTransaction(history, id, mod);
183     }
184
185     // Sequence has already been checked
186     @Override
187     @Nullable TransactionSuccess<?> doHandleRequest(final TransactionRequest<?> request, final RequestEnvelope envelope,
188             final long now) throws RequestException {
189         if (request instanceof ModifyTransactionRequest) {
190             return handleModifyTransaction((ModifyTransactionRequest) request, envelope, now);
191         } else if (request instanceof CommitLocalTransactionRequest) {
192             handleCommitLocalTransaction((CommitLocalTransactionRequest) request, envelope, now);
193             return null;
194         } else if (request instanceof ExistsTransactionRequest) {
195             return handleExistsTransaction((ExistsTransactionRequest) request);
196         } else if (request instanceof ReadTransactionRequest) {
197             return handleReadTransaction((ReadTransactionRequest) request);
198         } else if (request instanceof TransactionPreCommitRequest) {
199             handleTransactionPreCommit((TransactionPreCommitRequest) request, envelope, now);
200             return null;
201         } else if (request instanceof TransactionDoCommitRequest) {
202             handleTransactionDoCommit((TransactionDoCommitRequest) request, envelope, now);
203             return null;
204         } else if (request instanceof TransactionAbortRequest) {
205             return handleTransactionAbort(request.getSequence(), envelope, now);
206         } else if (request instanceof AbortLocalTransactionRequest) {
207             handleLocalTransactionAbort(request.getSequence(), envelope, now);
208             return null;
209         } else {
210             LOG.warn("Rejecting unsupported request {}", request);
211             throw new UnsupportedRequestException(request);
212         }
213     }
214
215     @Override
216     void retire() {
217         state = new Retired(state);
218     }
219
220     private void handleTransactionPreCommit(final TransactionPreCommitRequest request,
221             final RequestEnvelope envelope, final long now) throws RequestException {
222         throwIfFailed();
223
224         final Ready ready = checkReady();
225         switch (ready.stage) {
226             case PRE_COMMIT_PENDING:
227                 LOG.debug("{}: Transaction {} is already preCommitting", persistenceId(), getIdentifier());
228                 break;
229             case CAN_COMMIT_COMPLETE:
230                 ready.stage = CommitStage.PRE_COMMIT_PENDING;
231                 LOG.debug("{}: Transaction {} initiating preCommit", persistenceId(), getIdentifier());
232                 ready.readyCohort.preCommit(new FutureCallback<DataTreeCandidate>() {
233                     @Override
234                     public void onSuccess(final DataTreeCandidate result) {
235                         successfulPreCommit(envelope, now);
236                     }
237
238                     @Override
239                     public void onFailure(final Throwable failure) {
240                         failTransaction(envelope, now, new RuntimeRequestException("Precommit failed", failure));
241                     }
242                 });
243                 break;
244             case CAN_COMMIT_PENDING:
245             case COMMIT_PENDING:
246             case PRE_COMMIT_COMPLETE:
247             case READY:
248                 throw new IllegalStateException("Attempted to preCommit in stage " + ready.stage);
249             default:
250                 throwUnhandledCommitStage(ready);
251         }
252     }
253
254     void successfulPreCommit(final RequestEnvelope envelope, final long startTime) {
255         if (state instanceof Retired) {
256             LOG.debug("{}: Suppressing successful preCommit of retired transaction {}", persistenceId(),
257                 getIdentifier());
258             return;
259         }
260
261         final Ready ready = checkReady();
262         LOG.debug("{}: Transaction {} completed preCommit", persistenceId(), getIdentifier());
263         recordAndSendSuccess(envelope, startTime, new TransactionPreCommitSuccess(getIdentifier(),
264             envelope.getMessage().getSequence()));
265         ready.stage = CommitStage.PRE_COMMIT_COMPLETE;
266     }
267
268     void failTransaction(final RequestEnvelope envelope, final long now, final RuntimeRequestException cause) {
269         if (state instanceof Retired) {
270             LOG.debug("{}: Suppressing failure of retired transaction {}", persistenceId(), getIdentifier(), cause);
271             return;
272         }
273
274         recordAndSendFailure(envelope, now, cause);
275         state = new Failed(cause);
276         LOG.debug("{}: Transaction {} failed", persistenceId(), getIdentifier(), cause);
277     }
278
279     private void handleTransactionDoCommit(final TransactionDoCommitRequest request, final RequestEnvelope envelope,
280             final long now) throws RequestException {
281         throwIfFailed();
282
283         final Ready ready = checkReady();
284         switch (ready.stage) {
285             case COMMIT_PENDING:
286                 LOG.debug("{}: Transaction {} is already committing", persistenceId(), getIdentifier());
287                 break;
288             case PRE_COMMIT_COMPLETE:
289                 ready.stage = CommitStage.COMMIT_PENDING;
290                 LOG.debug("{}: Transaction {} initiating commit", persistenceId(), getIdentifier());
291                 ready.readyCohort.commit(new FutureCallback<UnsignedLong>() {
292                     @Override
293                     public void onSuccess(final UnsignedLong result) {
294                         successfulCommit(envelope, now);
295                     }
296
297                     @Override
298                     public void onFailure(final Throwable failure) {
299                         failTransaction(envelope, now, new RuntimeRequestException("Commit failed", failure));
300                     }
301                 });
302                 break;
303             case CAN_COMMIT_COMPLETE:
304             case CAN_COMMIT_PENDING:
305             case PRE_COMMIT_PENDING:
306             case READY:
307                 throw new IllegalStateException("Attempted to doCommit in stage " + ready.stage);
308             default:
309                 throwUnhandledCommitStage(ready);
310         }
311     }
312
313     private void handleLocalTransactionAbort(final long sequence, final RequestEnvelope envelope, final long now) {
314         checkOpen().abort(() -> recordAndSendSuccess(envelope, now, new TransactionAbortSuccess(getIdentifier(),
315             sequence)));
316     }
317
318     private void startAbort() {
319         state = ABORTING;
320         LOG.debug("{}: Transaction {} aborting", persistenceId(), getIdentifier());
321     }
322
323     private void finishAbort() {
324         state = ABORTED;
325         LOG.debug("{}: Transaction {} aborted", persistenceId(), getIdentifier());
326     }
327
328     private TransactionAbortSuccess handleTransactionAbort(final long sequence, final RequestEnvelope envelope,
329             final long now) {
330         if (state instanceof Open) {
331             final ReadWriteShardDataTreeTransaction openTransaction = checkOpen();
332             startAbort();
333             openTransaction.abort(() -> {
334                 recordAndSendSuccess(envelope, now, new TransactionAbortSuccess(getIdentifier(),
335                     sequence));
336                 finishAbort();
337             });
338             return null;
339         }
340         if (ABORTING.equals(state)) {
341             LOG.debug("{}: Transaction {} already aborting", persistenceId(), getIdentifier());
342             return null;
343         }
344         if (ABORTED.equals(state)) {
345             // We should have recorded the reply
346             LOG.warn("{}: Transaction {} already aborted", persistenceId(), getIdentifier());
347             return new TransactionAbortSuccess(getIdentifier(), sequence);
348         }
349
350         final Ready ready = checkReady();
351         startAbort();
352         ready.readyCohort.abort(new FutureCallback<Void>() {
353             @Override
354             public void onSuccess(final Void result) {
355                 recordAndSendSuccess(envelope, now, new TransactionAbortSuccess(getIdentifier(), sequence));
356                 finishAbort();
357             }
358
359             @Override
360             public void onFailure(final Throwable failure) {
361                 recordAndSendFailure(envelope, now, new RuntimeRequestException("Abort failed", failure));
362                 LOG.warn("{}: Transaction {} abort failed", persistenceId(), getIdentifier(), failure);
363                 finishAbort();
364             }
365         });
366         return null;
367     }
368
369     private void coordinatedCommit(final RequestEnvelope envelope, final long now) throws RequestException {
370         throwIfFailed();
371
372         final Ready ready = checkReady();
373         switch (ready.stage) {
374             case CAN_COMMIT_PENDING:
375                 LOG.debug("{}: Transaction {} is already canCommitting", persistenceId(), getIdentifier());
376                 break;
377             case READY:
378                 ready.stage = CommitStage.CAN_COMMIT_PENDING;
379                 LOG.debug("{}: Transaction {} initiating canCommit", persistenceId(), getIdentifier());
380                 checkReady().readyCohort.canCommit(new FutureCallback<Void>() {
381                     @Override
382                     public void onSuccess(final Void result) {
383                         successfulCanCommit(envelope, now);
384                     }
385
386                     @Override
387                     public void onFailure(final Throwable failure) {
388                         failTransaction(envelope, now, new RuntimeRequestException("CanCommit failed", failure));
389                     }
390                 });
391                 break;
392             case CAN_COMMIT_COMPLETE:
393             case COMMIT_PENDING:
394             case PRE_COMMIT_COMPLETE:
395             case PRE_COMMIT_PENDING:
396                 throw new IllegalStateException("Attempted to canCommit in stage " + ready.stage);
397             default:
398                 throwUnhandledCommitStage(ready);
399         }
400     }
401
402     void successfulCanCommit(final RequestEnvelope envelope, final long startTime) {
403         if (state instanceof Retired) {
404             LOG.debug("{}: Suppressing successful canCommit of retired transaction {}", persistenceId(),
405                 getIdentifier());
406             return;
407         }
408
409         final Ready ready = checkReady();
410         recordAndSendSuccess(envelope, startTime, new TransactionCanCommitSuccess(getIdentifier(),
411             envelope.getMessage().getSequence()));
412         ready.stage = CommitStage.CAN_COMMIT_COMPLETE;
413         LOG.debug("{}: Transaction {} completed canCommit", persistenceId(), getIdentifier());
414     }
415
416     private void directCommit(final RequestEnvelope envelope, final long now) throws RequestException {
417         throwIfFailed();
418
419         final Ready ready = checkReady();
420         switch (ready.stage) {
421             case CAN_COMMIT_COMPLETE:
422             case CAN_COMMIT_PENDING:
423             case COMMIT_PENDING:
424             case PRE_COMMIT_COMPLETE:
425             case PRE_COMMIT_PENDING:
426                 LOG.debug("{}: Transaction {} in state {}, not initiating direct commit for {}", persistenceId(),
427                     getIdentifier(), state, envelope);
428                 break;
429             case READY:
430                 ready.stage = CommitStage.CAN_COMMIT_PENDING;
431                 LOG.debug("{}: Transaction {} initiating direct canCommit", persistenceId(), getIdentifier());
432                 ready.readyCohort.canCommit(new FutureCallback<Void>() {
433                     @Override
434                     public void onSuccess(final Void result) {
435                         successfulDirectCanCommit(envelope, now);
436                     }
437
438                     @Override
439                     public void onFailure(final Throwable failure) {
440                         failTransaction(envelope, now, new RuntimeRequestException("CanCommit failed", failure));
441                     }
442                 });
443                 break;
444             default:
445                 throwUnhandledCommitStage(ready);
446         }
447     }
448
449     void successfulDirectCanCommit(final RequestEnvelope envelope, final long startTime) {
450         if (state instanceof Retired) {
451             LOG.debug("{}: Suppressing direct canCommit of retired transaction {}", persistenceId(), getIdentifier());
452             return;
453         }
454
455         final Ready ready = checkReady();
456         ready.stage = CommitStage.PRE_COMMIT_PENDING;
457         LOG.debug("{}: Transaction {} initiating direct preCommit", persistenceId(), getIdentifier());
458         ready.readyCohort.preCommit(new FutureCallback<DataTreeCandidate>() {
459             @Override
460             public void onSuccess(final DataTreeCandidate result) {
461                 successfulDirectPreCommit(envelope, startTime);
462             }
463
464             @Override
465             public void onFailure(final Throwable failure) {
466                 failTransaction(envelope, startTime, new RuntimeRequestException("PreCommit failed", failure));
467             }
468         });
469     }
470
471     void successfulDirectPreCommit(final RequestEnvelope envelope, final long startTime) {
472         if (state instanceof Retired) {
473             LOG.debug("{}: Suppressing direct commit of retired transaction {}", persistenceId(), getIdentifier());
474             return;
475         }
476
477         final Ready ready = checkReady();
478         ready.stage = CommitStage.COMMIT_PENDING;
479         LOG.debug("{}: Transaction {} initiating direct commit", persistenceId(), getIdentifier());
480         ready.readyCohort.commit(new FutureCallback<UnsignedLong>() {
481             @Override
482             public void onSuccess(final UnsignedLong result) {
483                 successfulCommit(envelope, startTime);
484             }
485
486             @Override
487             public void onFailure(final Throwable failure) {
488                 failTransaction(envelope, startTime, new RuntimeRequestException("DoCommit failed", failure));
489             }
490         });
491     }
492
493     void successfulCommit(final RequestEnvelope envelope, final long startTime) {
494         if (state instanceof Retired) {
495             LOG.debug("{}: Suppressing commit response on retired transaction {}", persistenceId(), getIdentifier());
496             return;
497         }
498
499         recordAndSendSuccess(envelope, startTime, new TransactionCommitSuccess(getIdentifier(),
500             envelope.getMessage().getSequence()));
501         state = COMMITTED;
502     }
503
504     private void handleCommitLocalTransaction(final CommitLocalTransactionRequest request,
505             final RequestEnvelope envelope, final long now) throws RequestException {
506         final DataTreeModification sealedModification = checkSealed();
507         if (!sealedModification.equals(request.getModification())) {
508             LOG.warn("Expecting modification {}, commit request has {}", sealedModification, request.getModification());
509             throw new UnsupportedRequestException(request);
510         }
511
512         final java.util.Optional<Exception> optFailure = request.getDelayedFailure();
513         if (optFailure.isPresent()) {
514             state = new Ready(history().createFailedCohort(getIdentifier(), sealedModification, optFailure.get()));
515         } else {
516             state = new Ready(history().createReadyCohort(getIdentifier(), sealedModification));
517         }
518
519         if (request.isCoordinated()) {
520             coordinatedCommit(envelope, now);
521         } else {
522             directCommit(envelope, now);
523         }
524     }
525
526     private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request)
527             throws RequestException {
528         final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(checkOpen().getSnapshot().readNode(
529             request.getPath()));
530         return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(getIdentifier(), request.getSequence(),
531             data.isPresent()));
532     }
533
534     private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request)
535             throws RequestException {
536         final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(checkOpen().getSnapshot().readNode(
537             request.getPath()));
538         return recordSuccess(request.getSequence(), new ReadTransactionSuccess(getIdentifier(), request.getSequence(),
539             data));
540     }
541
542     private ModifyTransactionSuccess replyModifySuccess(final long sequence) {
543         return recordSuccess(sequence, new ModifyTransactionSuccess(getIdentifier(), sequence));
544     }
545
546     private void applyModifications(final Collection<TransactionModification> modifications) {
547         if (!modifications.isEmpty()) {
548             final DataTreeModification modification = checkOpen().getSnapshot();
549             for (TransactionModification m : modifications) {
550                 if (m instanceof TransactionDelete) {
551                     modification.delete(m.getPath());
552                 } else if (m instanceof TransactionWrite) {
553                     modification.write(m.getPath(), ((TransactionWrite) m).getData());
554                 } else if (m instanceof TransactionMerge) {
555                     modification.merge(m.getPath(), ((TransactionMerge) m).getData());
556                 } else {
557                     LOG.warn("{}: ignoring unhandled modification {}", persistenceId(), m);
558                 }
559             }
560         }
561     }
562
563     @Nullable
564     private TransactionSuccess<?> handleModifyTransaction(final ModifyTransactionRequest request,
565             final RequestEnvelope envelope, final long now) throws RequestException {
566         // We need to examine the persistence protocol first to see if this is an idempotent request. If there is no
567         // protocol, there is nothing for us to do.
568         final java.util.Optional<PersistenceProtocol> maybeProto = request.getPersistenceProtocol();
569         if (!maybeProto.isPresent()) {
570             applyModifications(request.getModifications());
571             return replyModifySuccess(request.getSequence());
572         }
573
574         switch (maybeProto.get()) {
575             case ABORT:
576                 if (ABORTING.equals(state)) {
577                     LOG.debug("{}: Transaction {} already aborting", persistenceId(), getIdentifier());
578                     return null;
579                 }
580                 final ReadWriteShardDataTreeTransaction openTransaction = checkOpen();
581                 startAbort();
582                 openTransaction.abort(() -> {
583                     recordAndSendSuccess(envelope, now, new ModifyTransactionSuccess(getIdentifier(),
584                         request.getSequence()));
585                     finishAbort();
586                 });
587                 return null;
588             case READY:
589                 ensureReady(request.getModifications());
590                 return replyModifySuccess(request.getSequence());
591             case SIMPLE:
592                 ensureReady(request.getModifications());
593                 directCommit(envelope, now);
594                 return null;
595             case THREE_PHASE:
596                 ensureReady(request.getModifications());
597                 coordinatedCommit(envelope, now);
598                 return null;
599             default:
600                 LOG.warn("{}: rejecting unsupported protocol {}", persistenceId(), maybeProto.get());
601                 throw new UnsupportedRequestException(request);
602         }
603     }
604
605     private void ensureReady(final Collection<TransactionModification> modifications) {
606         // We may have a combination of READY + SIMPLE/THREE_PHASE , in which case we want to ready the transaction
607         // only once.
608         if (state instanceof Ready) {
609             LOG.debug("{}: {} is already in state {}", persistenceId(), getIdentifier(), state);
610             return;
611         }
612
613         applyModifications(modifications);
614         state = new Ready(checkOpen().ready());
615         LOG.debug("{}: transitioned {} to ready", persistenceId(), getIdentifier());
616     }
617
618     private void throwIfFailed() throws RequestException {
619         if (state instanceof Failed) {
620             LOG.debug("{}: {} has failed, rejecting request", persistenceId(), getIdentifier());
621             throw ((Failed) state).cause;
622         }
623     }
624
625     private ReadWriteShardDataTreeTransaction checkOpen() {
626         Preconditions.checkState(state instanceof Open, "%s expect to be open, is in state %s", getIdentifier(),
627             state);
628         return ((Open) state).openTransaction;
629     }
630
631     private Ready checkReady() {
632         Preconditions.checkState(state instanceof Ready, "%s expect to be ready, is in state %s", getIdentifier(),
633             state);
634         return (Ready) state;
635     }
636
637     private DataTreeModification checkSealed() {
638         Preconditions.checkState(state instanceof Sealed, "%s expect to be sealed, is in state %s", getIdentifier(),
639             state);
640         return ((Sealed) state).sealedModification;
641     }
642
643     private static void throwUnhandledCommitStage(final Ready ready) {
644         throw new IllegalStateException("Unhandled commit stage " + ready.stage);
645     }
646 }

©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.