2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
10 * Class which will monitor the completion of a FlowEntryDistributionOrder it
11 * implements a Future interface so it can be inspected by who is waiting for
14 package org.opendaylight.controller.forwardingrulesmanager.internal;
16 import java.util.concurrent.CountDownLatch;
17 import java.util.concurrent.ExecutionException;
18 import java.util.concurrent.Future;
19 import java.util.concurrent.TimeUnit;
20 import java.util.concurrent.TimeoutException;
22 import org.opendaylight.controller.forwardingrulesmanager.implementation.data.FlowEntryDistributionOrder;
23 import org.opendaylight.controller.sal.utils.Status;
24 import org.opendaylight.controller.sal.utils.StatusCode;
25 import org.slf4j.Logger;
26 import org.slf4j.LoggerFactory;
29 * Class which will monitor the completion of a FlowEntryDistributionOrder it
30 * implements a Future interface so it can be inspected by who is waiting for
33 final class FlowEntryDistributionOrderFutureTask implements Future<Status> {
34 private final FlowEntryDistributionOrder order;
35 private boolean amICancelled;
36 private CountDownLatch waitingLatch;
37 private Status retStatus;
38 private static final Logger logger = LoggerFactory.getLogger(FlowEntryDistributionOrderFutureTask.class);
39 // Don't wait forever to program, rather timeout if there are issues, and
42 private static final Long DEFAULTTIMEOUT = 30000L;
46 * for which we are monitoring the execution
48 FlowEntryDistributionOrderFutureTask(FlowEntryDistributionOrder order) {
49 // Order being monitored
51 this.amICancelled = false;
52 // We need to wait for one completion to happen
53 this.waitingLatch = new CountDownLatch(1);
54 // No return status yet!
55 this.retStatus = new Status(StatusCode.UNDEFINED);
57 String strTimeout = System.getProperty("FlowEntryDistributionOrderFutureTask.timeout",
58 DEFAULTTIMEOUT.toString());
60 timeout = Long.parseLong(strTimeout);
61 } catch (Exception e) {
62 timeout = DEFAULTTIMEOUT;
67 public boolean cancel(boolean mayInterruptIfRunning) {
72 public Status get() throws InterruptedException, ExecutionException {
73 boolean didFinish = false;
74 logger.trace("Getting status for order {}", this.order);
75 // If i'm done lets return the status as many times as caller wants
76 if (this.waitingLatch.getCount() == 0L) {
77 logger.trace("get returns the status without waiting");
81 logger.trace("Start waiting for status to come back");
82 // Wait till someone signal that we are done
83 didFinish = this.waitingLatch.await(this.timeout, TimeUnit.MILLISECONDS);
86 logger.trace("Waiting for the status of order {} is over, returning it", this.order);
87 // Return the known status
90 logger.error("Timing out, the workStatus for order {} has not come back in time!", this.order);
91 return new Status(StatusCode.TIMEOUT);
96 public Status get(long timeout, TimeUnit unit) throws InterruptedException,
97 ExecutionException, TimeoutException {
98 boolean didFinish = false;
99 logger.trace("Getting status for order {}", this.order);
100 // If i'm done lets return the status as many times as caller wants
101 if (this.waitingLatch.getCount() == 0L) {
102 logger.trace("get returns the status without waiting");
106 logger.trace("Start waiting for status to come back");
107 // Wait till someone signal that we are done
108 didFinish = this.waitingLatch.await(timeout, unit);
111 logger.trace("Waiting for the status is over, returning it");
112 // Return the known status, could also be null if didn't return
115 // No need to bark here as long as this routine could indeed
117 logger.trace("Timing out, the workStatus for order {} has not come back in time!", this.order);
118 return new Status(StatusCode.TIMEOUT);
123 public boolean isCancelled() {
124 return this.amICancelled;
128 public boolean isDone() {
129 return (this.waitingLatch.getCount() == 0L);
133 * Used by the thread that gets back the status for the order so can unblock
134 * an eventual caller waiting on the result to comes back
139 void gotStatus(FlowEntryDistributionOrder order, Status retStatus) {
140 logger.trace("Got status for order:{} \n Status:{}", order, retStatus);
141 if (!order.equals(this.order)) {
142 logger.error("Didn't get a result for an order we did issue order expected:{}, order received:{}",
144 // Weird we got a call for an order we didn't make
147 this.retStatus = retStatus;
148 // Now we are not waiting any longer
149 this.waitingLatch.countDown();
150 logger.trace("Unlocked the Future");
154 * Getter for the workOrder for which the order is waiting for
157 public FlowEntryDistributionOrder getOrder() {