Merge branch 'master' into compute

Conflicts:
	examples/skel.py
	kahuna/plugins/deployer.py
	kahuna/plugins/env.py
	kahuna/plugins/machine.py
	kahuna/plugins/shell.py
	kahuna/plugins/template.py
	kahuna/plugins/vdc.py
	kahuna/plugins/vm.py
	kahuna/plugins/volume.py

Author: Ignasi Barrera

.gitignore

@@ -5,4 +5,5 @@
 *.swp
 *.tmp
 catalina.base_IS_UNDEFINED
+target/
 

config/kahuna.conf

@@ -1,7 +1,7 @@
 # Main configuration file for Kahuna
 
 [connection]
-address = 10.60.1.222
+address = 10.60.21.181
 user = admin
 pass = xabiquo
 

examples/skel.py

@@ -9,24 +9,21 @@
 # The documentation string in the plugin class will be used to
 # print the help of the plugin.
 
+from kahuna.abstract import AbsPlugin
 
-class SkeletonPlugin:
-    """ An example plugin that prints dummy messages """
+
+class SkeletonPlugin(AbsPlugin):
+    """ An example plugin that prints dummy messages. """
     def __init__(self):
         pass
 
-    def commands(self):
-        """ Returns the provided commands, mapped to handler methods """
-        commands = {}
-        # Bind the 'print' plugin command to the 'print_handler' method
-        commands['print'] = self.print_handler
-        return commands
-
+    # Public methods will be considered plugin commands.
+    # The name of the command will be the method name.
     # The documentation string in command methods will be used to
     # print the help of the command.
     # The arguments are the options given to the command itself
-    def print_handler(self, args):
-        """ Prints a dummy message """
+    def dummy(self, args):
+        """ Prints a dummy message. """
         print "This is the print_handler in the example plugin"
 
 

kahuna/abstract.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env jython
+
+
+class AbsPlugin:
+    """ Abstract plugin. """
+    def _commands(self):
+        """ Get the list of commands for the current plugin.
+        By default all public methods in the plugin implementation
+        will be used as plugin commands. This method can be overriden
+        in subclasses to customize the available command list. """
+        attrs = filter(lambda attr: not attr.startswith('_'), dir(self))
+        commands = {}
+        for attr in attrs:
+            method = getattr(self, attr)
+            commands[attr] = method
+        return commands
+
+    def _load_context(self, context):
+        """ Set the context of the execution.
+
+        It should be called only from the plugin manager once
+        it has the context loaded.
+        """
+        self._context = context

kahuna/cli.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env jython
-
-import sys
 from pluginmanager import PluginManager
+import sys
 
 
 class CLI:
@@ -24,8 +23,9 @@ def parse_input(self):
         else:
             # Call the command in the given plugin with the
             # remaining of the arguments
-            return self.__pluginmanager.call(sys.argv[1], sys.argv[2],
-                    sys.argv[3:])
+            return self.__pluginmanager.call(sys.argv[1],
+                        sys.argv[2], sys.argv[3:])
+
 
 if __name__ == "__main__":
     cli = CLI()

kahuna/pluginmanager.py

@@ -1,7 +1,10 @@
 #!/usr/bin/env jython
 
+from __future__ import with_statement  # jython 2.5.2 issue
 import logging
 from plugins import __all__
+from kahuna.session import ContextLoader
+from contextlib import contextmanager
 
 log = logging.getLogger('kahuna')
 
@@ -27,14 +30,21 @@ def load_plugin(self, plugin_name):
         return plugin
 
     def call(self, plugin_name, command_name, args):
+        """ Encapsulate the call into a context already loaded.
+        """
+        with opencontext() as context:
+            return self._call(context, plugin_name, command_name, args)
+
+    def _call(self, context, plugin_name, command_name, args):
         """ Calls the given command on the given plugin. """
         try:
             plugin = self.load_plugin(plugin_name)
+            plugin._load_context(context)
             if not command_name:
                 self.help(plugin)
             else:
                 try:
-                    command = plugin.commands()[command_name]
+                    command = plugin._commands()[command_name]
                     return command(args)
                 except KeyError:
                     # Command not found in plugin. Print only plugin help
@@ -45,7 +55,7 @@ def call(self, plugin_name, command_name, args):
 
     def help(self, plugin):
         """ Prints the help for the given plugin. """
-        commands = plugin.commands()
+        commands = plugin._commands()
         tokens = plugin.__module__.split('.')
         plugin_name = tokens[len(tokens) - 1]
         print "%s" % plugin.__doc__
@@ -59,3 +69,14 @@ def help_all(self):
             plugin = self.load_plugin(name)
             self.help(plugin)
             print
+
+
+@contextmanager
+def opencontext():
+    """ Loads the context each plugin needs to be initialized
+    in order to be executed. """
+    log.debug("Loading context for plugin execution")
+    context = ContextLoader().load()
+    yield context
+    log.debug("Context closed after plugin execution")
+    context.close()

kahuna/plugins/deployer.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env jython
+
+import time
+from optparse import OptionParser
+from org.jclouds.abiquo.domain.exception import AbiquoException
+from org.jclouds.rest import AuthorizationException
+from kahuna.abstract import AbsPlugin
+
+
+class DeployerPlugin(AbsPlugin):
+    """ Massive deployer plugin. """
+    def __init__(self):
+        pass
+
+    def start(self, args):
+        """ Deploys and undeploys the first virtual appliance N times. """
+        # Parse user input to get the number of deployments and undeployments
+        parser = OptionParser(usage="deployer start <options>")
+        parser.add_option("-n", "--num", dest="num",
+                help="The number of deployments to execute")
+        (options, args) = parser.parse_args(args)
+        if not options.num:
+            parser.print_help()
+            return
+
+        # Once user input has been read, find the VM
+        max = int(options.num)
+        try:
+            cloud = self._context.getCloudService()
+            monitor = self._context.getMonitoringService() \
+                    .getVirtualApplianceMonitor()
+
+            vdc = cloud.listVirtualDatacenters()[0]
+            vapp = vdc.listVirtualAppliances()[0]
+            num_vms = len(vapp.listVirtualMachines())
+
+            print "Starting %s deployment iterations for %s (%s vms)" % (max,
+                    vapp.getName(), num_vms)
+
+            for i in range(0, max):
+                print "Iteration #%s" % (i + 1)
+                print "  Deploying %s (%s vms)" % (vapp.getName(), num_vms)
+                vapp.deploy()
+                monitor.awaitCompletionDeploy(vapp)
+
+                # Bypass current issues with state by waiting a bit
+                # before undeploying
+                time.sleep(5)
+
+                print "  Undeploying %s (%s vms)" % (vapp.getName(), num_vms)
+                vapp.undeploy()
+                monitor.awaitCompletionUndeploy(vapp)
+
+                # Currently there is a minor issue when undeploying that puts
+                # the vm in state UNKNOWN. Wait a bit so it gets in
+                # NOT_ALLOCATED state before deploying again
+                time.sleep(5)
+        except (AbiquoException, AuthorizationException), ex:
+            print "Error: %s" % ex.getMessage()
+
+
+def load():
+    """ Loads the deployer plugin. """
+    return DeployerPlugin()

kahuna/plugins/env.py

@@ -11,50 +11,37 @@
 from environment.users.tenants import cleanup_default_tenants
 from environment.users.tenants import create_default_tenants
 from kahuna.config import ConfigLoader
-from kahuna.session import ContextLoader
 from org.jclouds.abiquo.domain.exception import AbiquoException
 from org.jclouds.rest import AuthorizationException
+from kahuna.abstract import AbsPlugin
 
 
-class EnvironmentPlugin:
-    """ Environment generator plugin """
+class EnvironmentPlugin(AbsPlugin):
+    """ Environment generator plugin. """
     def __init__(self):
         self.__config = ConfigLoader().load("env.conf", "config/env.conf")
 
-    def commands(self):
-        """ Returns the available commands in this plugin """
-        commands = {}
-        commands['create'] = self.create
-        commands['clean'] = self.cleanup
-        return commands
-
     def create(self, args):
-        """ Creates the environment """
-        context = ContextLoader().load()
+        """ Creates the environment. """
         try:
-            apply_default_configuration(self.__config, context)
-            dc = create_infrastructure_compute(self.__config, context)
-            create_infrastructure_storage(self.__config, context, dc)
-            create_infrastructure_network(self.__config, context, dc)
-            create_default_tenants(self.__config, context, dc)
-            vdc = create_cloud_compute(self.__config, context, dc)
-            create_cloud_storage(self.__config, context, vdc)
+            apply_default_configuration(self.__config, self._context)
+            dc = create_infrastructure_compute(self.__config, self._context)
+            create_infrastructure_storage(self.__config, self._context, dc)
+            create_infrastructure_network(self.__config, self._context, dc)
+            create_default_tenants(self.__config, self._context, dc)
+            vdc = create_cloud_compute(self.__config, self._context, dc)
+            create_cloud_storage(self.__config, self._context, vdc)
         except (AbiquoException, AuthorizationException), ex:
             print "Error: %s" % ex.getMessage()
-        finally:
-            context.close()
 
-    def cleanup(self, args):
-        """ Cleans up the environment """
-        context = ContextLoader().load()
+    def clean(self, args):
+        """ Cleans up the environment. """
         try:
-            cleanup_cloud_compute(self.__config, context)
-            cleanup_default_tenants(self.__config, context)
-            cleanup_infrastructure_compute(self.__config, context)
+            cleanup_cloud_compute(self.__config, self._context)
+            cleanup_default_tenants(self.__config, self._context)
+            cleanup_infrastructure_compute(self.__config, self._context)
         except (AbiquoException, AuthorizationException), ex:
             print "Error: %s" % ex.getMessage()
-        finally:
-            context.close()
 
 
 def load():