Remove yang-test

[controller.git] / opendaylight / config / config-persister-feature-adapter / src / main / java / org / opendaylight / controller / configpusherfeature / internal / ConfigPushingRunnable.java

diff --git a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java
index b0e64b84d2adf4433fd378b8fca5d35eb97c4e19..010a27315428f3008f8a794830f9144bf6b21e7b 100644 (file)
--- a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java
+++ b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java
@@ -7,6 +7,8 @@
  */
 package org.opendaylight.controller.configpusherfeature.internal;
 
+import com.google.common.collect.LinkedHashMultimap;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
@@ -20,60 +22,61 @@ import org.opendaylight.controller.config.persist.api.ConfigPusher;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.google.common.collect.LinkedHashMultimap;
-
 public class ConfigPushingRunnable implements Runnable {
-    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigPushingRunnable.class);
+    private static final Logger LOG = LoggerFactory.getLogger(ConfigPushingRunnable.class);
     private static final int POLL_TIME = 1;
     private BlockingQueue<FeatureEvent> queue;
     private FeatureConfigPusher configPusher;
-    public ConfigPushingRunnable(ConfigPusher p, FeaturesService f,BlockingQueue<FeatureEvent> q) {
-        queue = q;
-        configPusher = new FeatureConfigPusher(p, f);
+
+    public ConfigPushingRunnable(final ConfigPusher configPusher, final FeaturesService featuresService,
+                                 final BlockingQueue<FeatureEvent> featureEvents) {
+        queue = featureEvents;
+        this.configPusher = new FeatureConfigPusher(configPusher, featuresService);
     }
 
     @Override
+    @SuppressWarnings("IllegalCatch")
     public void run() {
-        List<Feature> toInstall = new ArrayList<Feature>();
-        FeatureEvent event;
-        boolean interuppted = false;
-        while(true) {
+        List<Feature> toInstall = new ArrayList<>();
+        FeatureEvent event = null;
+        boolean interrupted = false;
+        while (true) {
             try {
-                if(!interuppted) {
-                        if(toInstall.isEmpty()) {
-                            event = queue.take();
-                        } else {
-                            event = queue.poll(POLL_TIME, TimeUnit.MILLISECONDS);
-                        }
-                        if(event != null && event.getFeature() !=null) {
-                            processFeatureEvent(event,toInstall);
-                        }
-                } else if(toInstall.isEmpty()) {
-                    LOGGER.error("ConfigPushingRunnable - exiting");
+                if (!interrupted) {
+                    if (toInstall.isEmpty()) {
+                        event = queue.take();
+                    } else {
+                        event = queue.poll(POLL_TIME, TimeUnit.MILLISECONDS);
+                    }
+                    if (event != null && event.getFeature() != null) {
+                        processFeatureEvent(event, toInstall);
+                    }
+                } else if (toInstall.isEmpty()) {
+                    LOG.error("ConfigPushingRunnable - exiting");
                     return;
                 }
-            } catch (InterruptedException e) {
-                LOGGER.error("ConfigPushingRunnable - interupted");
-                interuppted = true;
-            } catch (Exception e) {
-                LOGGER.error("Exception while processing features {}", e);
+            } catch (final InterruptedException e) {
+                LOG.error("ConfigPushingRunnable - interrupted");
+                interrupted = true;
+            } catch (final Exception e) {
+                LOG.error("Exception while processing features {} event {}", toInstall, event, e);
             }
         }
     }
 
-    protected void processFeatureEvent(FeatureEvent event, List<Feature> toInstall) throws InterruptedException, Exception {
-        if(event.getType() == EventType.FeatureInstalled) {
+    protected void processFeatureEvent(final FeatureEvent event, final List<Feature> toInstall) throws Exception {
+        if (event.getType() == EventType.FeatureInstalled) {
             toInstall.add(event.getFeature());
-            LinkedHashMultimap<Feature,FeatureConfigSnapshotHolder> result = configPusher.pushConfigs(toInstall);
+            LinkedHashMultimap<Feature, FeatureConfigSnapshotHolder> result = configPusher.pushConfigs(toInstall);
             toInstall.removeAll(result.keySet());
-        } else if(event.getType() == EventType.FeatureUninstalled) {
+        } else if (event.getType() == EventType.FeatureUninstalled) {
             toInstall.remove(event.getFeature());
         }
     }
 
-    protected void logPushResult(LinkedHashMultimap<Feature,FeatureConfigSnapshotHolder> results) {
-        for(Feature f:results.keySet()) {
-            LOGGER.info("Pushed configs for feature {} {}",f,results.get(f));
+    protected void logPushResult(final LinkedHashMultimap<Feature, FeatureConfigSnapshotHolder> results) {
+        for (Feature f : results.keySet()) {
+            LOG.info("Pushed configs for feature {} {}", f, results.get(f));
         }
     }
 }