API Microversioning¶

Background¶

The API Microversioning is a framework in Senlin to enable smooth evolution of the Senlin REST API while preserving its backward compatibility. The basic idea is that a user has to explicitly specify the particular version of API requested in the request. Disruptive changes to the API can then be added without breaking existing users who don’t specifically ask for it. This is done with an HTTP header OpenStack-API-Version as suggested by the OpenStack API Working Group. The value of the header should contain the service name (clustering) and the desired API version which is a monotonically increasing semantic version number starting from 1.0.

If a user makes a request without specifying a version, they will get the DEFAULT_API_VERSION as defined in senlin.api.common.wsgi. This value is currently 1.0 and is expected to remain so for quite a long time.

There is a special value “latest” which can be specified, which will allow a client to always invoke the most recent version of APIs from the server.

When to Bump the Microversion?¶

A microversion is needed when the contract to the user is changed. The user contract covers many kinds of information such as:

• the Request

  • the list of resource URLs which exist on the server

    Example: adding a new GET clusters/{ID}/foo resource which didn’t exist in a previous version of the code

  • the list of query parameters that are valid on URLs

    Example: adding a new parameter is_healthy when querying a node by GET nodes/{ID}?is_healthy=True

  • the list of query parameter values for non-freeform fields

    Example: parameter filters takes a small set of properties “A”, “B”, “C”, now support for new property “D” is added

  • new headers accepted on a request

  • the list of attributes and data structures accepted.

    Example: adding a new attribute 'locked': True/False to a request body

• the Response

  • the list of attributes and data structures returned

    Example: adding a new attribute 'locked': True/False to the output of GET clusters/{ID}

  • the allowed values of non-freeform fields

    Example: adding a new allowed “status” field to GET servers/{ID}

  • the list of status codes allowed for a particular request

    Example: an API previously could return 200, 400, 403, 404 and the change would make the API now also be allowed to return 409.

  • changing a status code on a particular response

    Example: changing the return code of an API from 501 to 400.

    Note

    According to the OpenStack API Working Group, a 500 Internal Server Error should NOT be returned to the user for failures due to user error that can be fixed by changing the request on the client side. This kind of a fix doesn’t require a change to the microversion.

  • new headers returned on a response

The following flow chart attempts to walk through the process of “do we need a microversion”.

When a Microversion Is Not Needed¶

A microversion is not needed in the following situations:

• the response
  • Changing the error message without changing the response code does not require a new microversion.
  • Removing an inapplicable HTTP header, for example, suppose the Retry-After HTTP header is being returned with a 4xx code. This header should only be returned with a 503 or 3xx response, so it may be removed without bumping the microversion.

Working with Microversions¶

In the senlin.api.common.wsgi module, we define an @api_version decorator which is intended to be used on top-level methods of controllers. It is not appropriate for lower-level methods.

@wsgi.Controller.api_version("2.4")
def my_api_method(self, req, id):
    ....

@wsgi.Controller.api_version("2.1", "2.4")
def my_api_method(self, req, id):
    ....

@wsgi.Controller.api_version("1.0", "2.3")
def my_api_method(self, req, id):
    .... method_1 ...

@wsgi.Controller.api_version("2.4")  # noqa
def my_api_method(self, req, id):
    .... method_2 ...

import senlin.api.common.version_request as vr

def index(self, req):
    # common code ...

    req_version = req.version_request
    req1_min = vr.APIVersionRequest("2.1")
    req1_max = vr.APIVersionRequest("2.5")
    req2_min = vr.APIVersionRequest("2.6")
    req2_max = vr.APIVersionRequest("2.10")

    if req_version.matches(req1_min, req1_max):
        # stuff...
    elif req_version.matches(req2min, req2_max):
        # other stuff...
    elif req_version > vr.APIVersionRequest("2.10"):
        # more stuff...

    # common code ...

null_version = APIVersionRequest()

Planning and Committing Changes¶

Once the idea of an API change is discussed with the core team and the concensus has been reached to bump the micro-version of Senlin API, you can start working on the changes in the following order:

1. Prepare the engine and possibly the action layer for the change. One STRICT requirement is that the newly proposed change(s) should not break any existing users.
2. Add a new versioned object if a new API is introduced; or modify the fields of an existing object representing the API request. You are expected to override the obj_make_compatible() method to ensure the request formed will work on an older version of engine.
3. If the change is about modifying an existing API, you will need to bump the version of the request object. You are also required to add or change the VERSION_MAP dictionary of the request object class where the key is the API microversion and the value is the object version. For example:

@base.SenlinObjectRegistry.register
class ClusterDanceRequest(base.SenlinObject):

    # VERSION 1.0: Initial version
    # VERSION 1.1: Add field 'style'
    VERSION = '1.1'
    VERSION_MAP = {
      'x.y': '1.1'
    }

    fields = {
      ...
      'style': fields.StringField(nullable=True),
    }

    def obj_make_compatible(self, primitive, target_version):
       # add the logic to convert the request for a target version
       ...

4. Patch the API layer to introduce the change. This involves changing the senlin/api/openstack/history.rst file to include the descriptive information about the changes made.
5. Revise the API reference documentation so that the changes are properly documented.
6. Add a release note entry for the API change.
7. Add tempest based API test and functional tests.
8. Update _MAX_API_VERSION in senlin.api.openstack.versions, if needed. Note that each time we bump the API microversion, we may introduce two or more changes rather than one single change, the update of _MAX_API_VERSION needs to be done only once if this is the case.
9. Commit patches to the python-openstacksdk project so that new API changes are accessible from client side.
10. Wait for the new release of python-openstacksdk project that includes the new changes and then propose changes to python-senlinclient project.

Allocating a microversion¶

If you are adding a patch which adds a new microversion, it is necessary to allocate the next microversion number. Except under extremely unusual circumstances, the minor number of _MAX_API_VERSION will be incremented. This will also be the new microversion number for the API change.

It is possible that multiple microversion patches would be proposed in parallel and the microversions would conflict between patches. This will cause a merge conflict. We don’t reserve a microversion for each patch in advance as we don’t know the final merge order. Developers may need over time to rebase their patch calculating a new version number as above based on the updated value of _MAX_API_VERSION.

API Version History¶

This document summarizes the changes made to the REST API with every bump of API microversion. The description for each version should be verbose so that it can be used by both users and developers.