opendaylight/forwardingrulesmanager/implementation/src/main/java/org/opendaylight/controller/forwardingrulesmanager/internal/FlowEntryDistributionOrderFutureTask.java

   1 /*
   2  * Copyright (c) 2013 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
   9 /**
  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
  12  * it.
  13  */
  14 package org.opendaylight.controller.forwardingrulesmanager.internal;
  15
  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;
  21
  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;
  27
  28 /**
  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
  31  * it.
  32  */
  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
  40     // log an error
  41     private long timeout;
  42     private static final Long DEFAULTTIMEOUT = 30000L;
  43
  44     /**
  45      * @param order
  46      *            for which we are monitoring the execution
  47      */
  48     FlowEntryDistributionOrderFutureTask(FlowEntryDistributionOrder order) {
  49         // Order being monitored
  50         this.order = order;
  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);
  56         // Set the timeout
  57         String strTimeout = System.getProperty("FlowEntryDistributionOrderFutureTask.timeout",
  58                                                DEFAULTTIMEOUT.toString());
  59         try {
  60             timeout = Long.parseLong(strTimeout);
  61         } catch (Exception e) {
  62             timeout = DEFAULTTIMEOUT;
  63         }
  64     }
  65
  66     @Override
  67     public boolean cancel(boolean mayInterruptIfRunning) {
  68         return false;
  69     }
  70
  71     @Override
  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");
  78             return retStatus;
  79         }
  80
  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);
  84
  85         if (didFinish) {
  86             logger.trace("Waiting for the status of order {} is over, returning it", this.order);
  87             // Return the known status
  88             return retStatus;
  89         } else {
  90             logger.error("Timing out, the workStatus for order {} has not come back in time!, it's hashcode is {}",
  91                     this.order, this.order.hashCode());
  92             return new Status(StatusCode.TIMEOUT);
  93         }
  94     }
  95
  96     @Override
  97     public Status get(long timeout, TimeUnit unit) throws InterruptedException,
  98             ExecutionException, TimeoutException {
  99         boolean didFinish = false;
 100         logger.trace("Getting status for order {}", this.order);
 101         // If i'm done lets return the status as many times as caller wants
 102         if (this.waitingLatch.getCount() == 0L) {
 103             logger.trace("get returns the status without waiting");
 104             return retStatus;
 105         }
 106
 107         logger.trace("Start waiting for status to come back");
 108         // Wait till someone signal that we are done
 109         didFinish = this.waitingLatch.await(timeout, unit);
 110
 111         if (didFinish) {
 112             logger.trace("Waiting for the status is over, returning it");
 113             // Return the known status, could also be null if didn't return
 114             return retStatus;
 115         } else {
 116             // No need to bark here as long as this routine could indeed
 117             // timeout
 118             logger.trace("Timing out, the workStatus for order {} has not come back in time!", this.order);
 119             return new Status(StatusCode.TIMEOUT);
 120         }
 121     }
 122
 123     @Override
 124     public boolean isCancelled() {
 125         return this.amICancelled;
 126     }
 127
 128     @Override
 129     public boolean isDone() {
 130         return (this.waitingLatch.getCount() == 0L);
 131     }
 132
 133     /**
 134      * Used by the thread that gets back the status for the order so can unblock
 135      * an eventual caller waiting on the result to comes back
 136      *
 137      * @param order
 138      * @param retStatus
 139      */
 140     void gotStatus(FlowEntryDistributionOrder order, Status retStatus) {
 141         logger.trace("Got status for order:{} \n Status:{}", order, retStatus);
 142         if (!order.equals(this.order)) {
 143             logger.error("Didn't get a result for an order we did issue order expected:{}, order received:{}",
 144                     this.order, order);
 145             // Weird we got a call for an order we didn't make
 146             return;
 147         }
 148         this.retStatus = retStatus;
 149         // Now we are not waiting any longer
 150         this.waitingLatch.countDown();
 151         logger.trace("Unlocked the Future");
 152     }
 153
 154     /**
 155      * Getter for the workOrder for which the order is waiting for
 156      * @return the order
 157      */
 158     public FlowEntryDistributionOrder getOrder() {
 159         return order;
 160     }
 161 }