Rally/HowToExtendRally

Extend Rally functionality

Add Deploy engines

Implementing your own deploy engines allows you to employ custom OpenStack platforms. Before starting to implement your own deploy engine, take a look at the already available deploy engines.

To implement a custom deploy engine, you need to create a subclass of rally.deploy.engine.EngineFactory and implement the __init__(), deploy() and cleanup() methods:

   from rally.deploy import engine
   from rally.serverprovider import provider
   class MyEngine(engine.EngineFactory):
       def __init__(self, task, config):
           self.task = task
           self._config = config
           self._vms = []
           provider_config = config['provider']
           self._vm_provider = provider.ProviderFactory.get_provider(provider_config)
           # Perform further initialization here
       def deploy(self):
           self._vms = self._vm_provider.create_vms()
           for vm in self._vms:
               # Deploy OpenStack on each VM here
           # Return the endpoints
           return {
               'identity': {
                   'url': 'http://$IDENTITY_HOST/',
                   'uri': 'http://$IDENTITY_HOST:5000/v2.0/',
                   'admin_username': '$ADMIN',
                   'admin_password': '$PASSWORD',
                   'admin_tenant_name': '$TENANT',
               }
           }
       def cleanup(self):
           # Cleanup the deployment here, e.g.
           self._vm_provider.destroy_vms()

Add Server providers

Implementing your own server providers allows you to use custom hardware/software configurations as well as virtualization strategies. Before starting to implement your own server provider, take a look at the already available server providers.

To implement a custom server provider, you need to create a subclass of rally.serverprovider.provider.ProviderFactory and implement 5 methods, namely __init__(), upload_image(), destroy_image(), create_servers() and destroy_servers():

    from rally.serverprovider import provider
      
    class MyProvider(provider.ProviderFactory):
 
       def create_servers(self):
            """Create VMs with chosen image.
            :param image_uuid: Indetificator of image
            :param type_id: VM type identificator
            :param amount: amount of required VMs
            :returns: list of provider.Server instances.
            """
            # Provide working servers with access via ssh
  
       def destroy_servers(self):
            """Destroy already created VMs."""
            # Destroy/Free allocated servers

Add Benchmark scenarios

Implementing your own benchmark scenarios allows you to benchmark your cloud against custom loading procedures. Before starting to implement your own benchmark scenarios, take a look at the already available benchmark scenarios.

To implement a custom benchmark scenario(s), you need to create a subclass of rally.benchmark.base.Scenario and implement each of the desired benchmarks in a separate method. The benchmark methods may be arbitrary named, but should be decorated by @classmethod (so they all take cls as their first parameter) and also take the context dictionary as the second parameter. In addition to the benchmark methods, overriding the class_init(), init() and cleanup() methods allows you to implement your own benchmark setup and cleanup strategies. init() differs from class_init() in that it should return a context dictionary (possibly with some objects predefined) which can then be used in the benchmark methods:

   from rally.benchmark import base
   class MyScenario(base.Scenario):
       @classmethod
       def init(cls, config):
           context = {}
           # Prepare the environment for benchmarking
           return context
       @classmethod
       def cleanup(cls, context):
           # Perform cleanup
       @classmethod
       def my_scenario_1(cls, context, my_arg):
           # Launch the benchmarking procedure
       @classmethod
       def my_scenario_2(cls, context, my_arg):
           # Launch the benchmarking procedure