Add a secondary booting vm example

This one uses rebinds to make simultaneous vms using
a parallel engine to run the non-dependent tasks at
the same time (the 2 vms are created at the same time).

Change-Id: I795fa279d777e7a54e7ef34bf88021600c70a506

taskflow/examples/fake_boot_vm2.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright (C) 2012-2013 Yahoo! Inc. All Rights Reserved.
+#
+#    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.
+
+import logging
+import os
+import random
+import sys
+
+logging.basicConfig(level=logging.ERROR)
+
+top_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                       os.pardir,
+                                       os.pardir))
+sys.path.insert(0, top_dir)
+
+from taskflow.patterns import graph_flow as gf
+from taskflow.patterns import linear_flow as lf
+
+from taskflow import engines
+from taskflow import task
+
+
+class PrintText(task.Task):
+    def __init__(self, print_what):
+        super(PrintText, self).__init__(name="Print: %s" % print_what)
+        self._text = print_what
+
+    def execute(self):
+        print("-" * (len(self._text)))
+        print(self._text)
+        print("-" * (len(self._text)))
+
+
+class AllocateIP(task.Task):
+    def execute(self):
+        return "192.168.0.%s" % (random.randint(1, 254))
+
+
+class AllocateVolumes(task.Task):
+    def execute(self):
+        volumes = []
+        for i in range(0, random.randint(0, 10)):
+            volumes.append("/dev/vda%s" % (i + 1))
+        return volumes
+
+
+class CreateVM(task.Task):
+    def execute(self, net_ip, volumes):
+        print("Making vm %s using ip %s" % (self.name, net_ip))
+        if volumes:
+            print("With volumes:")
+            for v in volumes:
+                print(" - %s" % (v))
+
+
+flow = lf.Flow("root").add(
+    PrintText("Starting"),
+    gf.Flow('maker').add(
+        # First vm creation
+        AllocateVolumes("volumes-1", provides='volumes_1'),
+        AllocateIP("ip-1", provides='net_ip1'),
+        CreateVM("vm-1", rebind=['net_ip1', 'volumes_1']),
+        # Second vm creation
+        AllocateVolumes("volumes-2", provides='volumes_2'),
+        AllocateIP("ip-2", provides='net_ip2'),
+        CreateVM("vm-2", rebind=['net_ip2', 'volumes_2'])
+    ),
+    PrintText("Finished"))
+
+
+# The above vms will be created in parallel, dependencies will be ran in order
+# so that means the ip and volume creation for each vm will run before the
+# final vm creation is done, but both vm creates will run at the same time.
+#
+# Pretty cool!
+engines.run(flow, engine_conf='parallel')