Extract a method to create a list of FlowRuleBatchOperation

- Define FlowRuleBatchOperationConvertionException, which is a
  new IntentException sub-class

Change-Id: I798303fa986f573c885b8712ac1dfee1bcaadf95

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.net.intent.impl;
+
+import com.google.common.collect.ImmutableList;
+import org.onosproject.net.flow.FlowRuleBatchOperation;
+import org.onosproject.net.intent.IntentException;
+
+import java.util.List;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+// TODO: Reconsider error handling and intent exception design. Otherwise, write Javadoc.
+public class FlowRuleBatchOperationConvertionException extends IntentException {
+
+    private final List<FlowRuleBatchOperation> converted;
+
+    public FlowRuleBatchOperationConvertionException(List<FlowRuleBatchOperation> converted, Throwable cause) {
+        super("exception occurred during IntentInstaller.install()", cause);
+        this.converted = ImmutableList.copyOf((checkNotNull(converted)));
+    }
+
+    public List<FlowRuleBatchOperation> converted() {
+        return converted;
+    }
+}

@@ -502,28 +502,29 @@ public class IntentManager
 
 
         @Override
         @Override
         public Optional<IntentUpdate> execute() {
         public Optional<IntentUpdate> execute() {
-            Exception exception = null;
+            try {
+                List<FlowRuleBatchOperation> converted = convert(installables);
+                // TODO: call FlowRuleService API to push FlowRules and track resources,
+                // which the submitted intent will use.
+                return Optional.of(new Installed(intent, installables, converted));
+            } catch (FlowRuleBatchOperationConvertionException e) {
+                log.warn("Unable to install intent {} due to:", intent.id(), e.getCause());
+                return Optional.of(new InstallingFailed(intent, installables, e.converted()));
+            }
+        }
+    }
 
 
-            List<FlowRuleBatchOperation> batches = Lists.newArrayList();
+    private List<FlowRuleBatchOperation> convert(List<Intent> installables) {
+        List<FlowRuleBatchOperation> batches = new ArrayList<>(installables.size());
         for (Intent installable : installables) {
         for (Intent installable : installables) {
-                registerSubclassInstallerIfNeeded(installable);
-                trackerService.addTrackedResources(intent.id(), installable.resources());
             try {
             try {
+                registerSubclassInstallerIfNeeded(installable);
                 batches.addAll(getInstaller(installable).install(installable));
                 batches.addAll(getInstaller(installable).install(installable));
             } catch (Exception e) { // TODO this should be IntentException
             } catch (Exception e) { // TODO this should be IntentException
-                    log.warn("Unable to install intent {} due to:", intent.id(), e);
-                    trackerService.removeTrackedResources(intent.id(), installable.resources());
-                    //TODO we failed; intent should be recompiled
-                    exception = e;
-                }
-            }
-
-            if (exception != null) {
-                return Optional.of(new InstallingFailed(intent, installables, batches));
+                throw new FlowRuleBatchOperationConvertionException(batches, e);
             }
             }
-
-            return Optional.of(new Installed(intent, installables, batches));
         }
         }
+        return batches;
     }
     }
 
 
     private class Withdrawing implements IntentUpdate {
     private class Withdrawing implements IntentUpdate {