另一个地址：http://neuromancer.sinaapp.com/?p=64

从nova client的入口查看

cat /usr/bin/nova

#!/usr/bin/python
# PBR Generated from ‘console_scripts‘

import sys

from novaclient.shell import main

if __name__ == "__main__":
    sys.exit(main())

def main():
    try:
        OpenStackComputeShell().main(map(strutils.safe_decode, sys.argv[1:]))

    except Exception as e:
        logger.debug(e, exc_info=1)
        print("ERROR: %s" % strutils.safe_encode(six.text_type(e)),
              file=sys.stderr)
        sys.exit(1)

OpenStackComputeShell.main()
        self.cs = client.Client(options.os_compute_api_version, os_username,
                os_password, os_tenant_name, tenant_id=os_tenant_id,
                auth_url=os_auth_url, insecure=insecure,
                region_name=os_region_name, endpoint_type=endpoint_type,
                extensions=self.extensions, service_type=service_type,
                service_name=service_name, auth_system=os_auth_system,
                auth_plugin=auth_plugin,
                volume_service_name=volume_service_name,
                timings=args.timings, bypass_url=bypass_url,
                os_cache=os_cache, http_log_debug=options.debug,
                cacert=cacert, timeout=timeout)

def get_client_class(version):
    version_map = {
        ‘1.1‘: ‘novaclient.v1_1.client.Client‘,
        ‘2‘: ‘novaclient.v1_1.client.Client‘,
        ‘3‘: ‘novaclient.v3.client.Client‘,
    }
    try:
        client_path = version_map[str(version)]
    except (KeyError, ValueError):
        msg = "Invalid client version ‘%s‘. must be one of: %s" % (
              (version, ‘, ‘.join(version_map.keys())))
        raise exceptions.UnsupportedVersion(msg)

    return utils.import_class(client_path)

def Client(version, *args, **kwargs):
    client_class = get_client_class(version)
    return client_class(*args, **kwargs)

class Client(object):
    """
    Top-level object to access the OpenStack Compute API.

    Create an instance with your creds::

        >>> client = Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL)

    Then call methods on its managers::

        >>> client.servers.list()
        ...
        >>> client.flavors.list()
        ...

    """

self.flavors = flavors.FlavorManager(self)

flavors.list() 进入novaclient.v1_1.flavors.py

class FlavorManager(base.ManagerWithFind):
    """
    Manage :class:`Flavor` resources.
    """
    resource_class = Flavor
    is_alphanum_id_allowed = True

    def list(self, detailed=True, is_public=True):
        """
        Get a list of all flavors.

        :rtype: list of :class:`Flavor`.
        """
        qparams = {}
        # is_public is ternary - None means give all flavors.
        # By default Nova assumes True and gives admins public flavors
        # and flavors from their own projects only.
        if not is_public:
            qparams[‘is_public‘] = is_public
        query_string = "?%s" % urlutils.urlencode(qparams) if qparams else ""

        detail = ""
        if detailed:
            detail = "/detail"

        return self._list("/flavors%s%s" % (detail, query_string), "flavors")

class Manager(utils.HookableMixin):
    """
    Managers interact with a particular type of API (servers, flavors, images,
    etc.) and provide CRUD operations for them.
    """
    resource_class = None

    def __init__(self, api):
        self.api = api

    def _list(self, url, response_key, obj_class=None, body=None):
        if body:
            _resp, body = self.api.client.post(url, body=body)
        else:
            _resp, body = self.api.client.get(url)

        if obj_class is None:
            obj_class = self.resource_class

        data = body[response_key]
        # NOTE(ja): keystone returns values as list as {‘values‘: [ ... ]}
        #           unlike other services which just return the list...
        if isinstance(data, dict):
            try:
                data = data[‘values‘]
            except KeyError:
                pass

        with self.completion_cache(‘human_id‘, obj_class, mode="w"):
            with self.completion_cache(‘uuid‘, obj_class, mode="w"):
                return [obj_class(self, res, loaded=True)
                        for res in data if res]

if body:
    _resp, body = self.api.client.post(url, body=body)
else:
    _resp, body = self.api.client.get(url)

通过self.api到了nova的api里nova.api.openstack.compute.__init__.py

        if init_only is None or ‘flavors‘ in init_only:
            self.resources[‘flavors‘] = flavors.create_resource()
            mapper.resource("flavor", "flavors",
                            controller=self.resources[‘flavors‘],
                            collection={‘detail‘: ‘GET‘},
                            member={‘action‘: ‘POST‘})

    @wsgi.serializers(xml=MinimalFlavorsTemplate)
    def index(self, req):
        """Return all flavors in brief."""
        limited_flavors = self._get_flavors(req)
        return self._view_builder.index(req, limited_flavors)

def _list_view(self, func, request, flavors):
    """Provide a view for a list of flavors."""
    flavor_list = [func(request, flavor)["flavor"] for flavor in flavors]
    flavors_links = self._get_collection_links(request,
            flavors,
            self._collection_name,
            "flavorid")
    flavors_dict = dict(flavors=flavor_list)

    if flavors_links:
        flavors_dict["flavors_links"] = flavors_links

    return flavors_dict

curl -i http://<nova_ip>:8774/v2/<tenant_id>/servers/<user_id>/backup_instance -X POST  -H "X-Auth-Project-Id: admin" -H "Content-Type: application/json" -H "User-Agent: python-novaclient" -H "Accept: application/json" -H "X-Auth-Token: <token>" -d ‘{"name" : "backup", "description" : "backup‘s description"}‘

@utils.arg(‘server‘, metavar=‘<server>‘, help=‘ID of server.‘)
@utils.arg(‘displayname‘,
            metavar=‘<name>‘,
            help=‘Display name for backup.‘)
@utils.arg(‘description‘,
            default=None,
            metavar=‘<description>‘,
            help=‘Description for backup.(Default None)‘)
def do_backup_instance(cs, args):
    """Make a quick backup for instance."""
    cs.servers.backup_instance(args.server,
                        args.displayname,
                        args.description)

def backup_instance(self, server, backup_name, backup_description):
    """
    Backup a server instance quickly.

    :param server: The :class:`Server` (or its ID) to share onto.
    :param backup_name: Name of the backup image
    :param backup_description: The backup description
    """
    body = {‘name‘: backup_name,
            ‘description‘: backup_description}
    response_key = "id"
    return self._create("/servers/%s/backup_instance" % base.getid(server),
                    body, response_key, return_raw=True)

novaclient的api调用流程与开发