OpenStack Restful API基础简介

Restful API开发框架简介

WSGI + Paste + Paste_Deploy + Routes + WebOb 这几个模块组合构成了 Openstack Restful API 的开发框架，它同时也是一个MVC框架，称为RackSpace。主要包括消息路由Router，控制器Controller、action等等。

由WSGI + Paste + Paste_Deploy 完成 Application 的 WSGI 化，其中 PasteDeploy 完成 WSGI Server 和 Application 的构建；

Routes 负责 URL 路由转发；

WebOb 完成了 WSGI 请求和响应的封装 。

使用该框架开发出来的 Restful API 能够满足 WSGI 规范的要求，但是弊端在于该框架比较复杂，代码量大。只有最初的几个 Openstack 核心项目在使用，后来的新生项目使用了一个相对而言更加简单便捷的 Pecan 框架。

RESTful API 程序的主要特点就是 URL_Path 会和功能对应起来。比如用户管理的功能一般都放在http://hostname:post/version//user这个路径下。因此，看一个 RESTful API 程序，一般都是看它实现了哪些 URL_Path，以及每个 URL_Path 对应了什么功能，这个一般都是由 Routes 的 URL 路由功能负责的。所以，熟悉一个RESTful API程序的重点在于确定URL路由。

一个模拟虚拟机管理的RESTful API实现

我们首先来实现一个虚拟机管理的RESTful API，用户可以通过发送HTTP请求，来对虚拟机进行管理（包括创建、查询、更新以及删除虚拟机等），在此只是保存相应的虚拟机记录，而不会真的在物理机上创建虚拟机。

实现的代码地址在：https://github.com/JiYou/openstack/tree/master/chap11/REST/wsgi_instance

一个http request到达RESTful API时的处理流程：

image

下面，我们分模块来理解整个RESTful API处理请求的流程。

1.WSGI协议

什么是WSGI
(1)、WSGI(Web 服务器网关接口)是python中所定义的Web Server和Web APP之间或框架之间的接口标准规范
(2)、WSGI接口规范的目的就是规范Web服务器与Web应用之间的交互，在协议之间进行转换
(3)、WSGI将Web组件分成三类：Web服务器(Server)、Web中间件(Middleware)与Web应用程序(APP)。

WSGI APP：指的是可以被调用的一个对象，一般指的是包含一个__call__方法(实例可以当作函数一般调用)的对象。
WSGI Server：指的是实现了调用应用的部分。
WSGI Middleware：处于服务器和应用两侧，起粘合作用，具体包括：请求处理、environ处理。

1.1什么是WSGI APP

WSGI APP是一个可调用的对象（callable object），可调用的对象有三种：

1.一个函数
2.一个实现__call__()方法的类
3.一个类的实例

这个对象接收两个参数environ和start_response。
environ是一个字典，里面储存了HTTP request的所有内容。而start_response是一个WSGI Server传递过来的函数，用于将response header,status传递给Server。并且它还需要返回一个可迭代的值，用于将response body传递给Server。
以可调用对象为一个类为例：

class application:
   def __call__(self, environ, start_response):
   status = '200 OK'
   response_headers = [('Content-type', 'text/plain')]
   start_response(status, response_headers)
   return [u"This is hello wsgi app".encode('utf8')

WSGI APP使用start_response(status, response_headers)这个函数将response header,status传递给Server，使用return(调用返回)将response body传递给Server，即将一个http response通过两个途径返回给了Server。

在OpenStack中，为了简化程序的书写，经常使用WebOb包中的wsgify装饰器将一个函数变为WSGI APP

class webob.dec.wsgify(func=None, RequestClass=None, args=(), kwargs=None, middleware_wraps=None)

如下所示

from webob.dec import wsgify
from webob import Request,Response
@wsgify
def myfunc(req):
    return Response('hey there')

此时APP的输入变成封装了environ字典的一个Request类，并且直接返回一个封装了所有http response信息的Response类即可。
装饰器还可以自定义，一般通过一个继承了webob.Request的子类(比如MyRequest)来实现，如下：

class MyRequest(webob.Request):  #python中的继承，子类继承Request类
    @property                    #只读
    def is_local(self):     
        return self.remote_addr == '127.0.0.1' 

@wsgify(RequestClass=MyRequest)
def myfunc(req):
    if req.is_local:
        return Response('hi!')
    else:
        raise webob.exc.HTTPForbidden

可以看到，经过这种方式，我们在Server和APP之间实现了一层过滤地址的功能（本机地址可以访问，其他地址则拒绝访问），实际上就实现了一个Middleware。

WebOb包的官方英文文档链接：https://docs.pylonsproject.org/projects/webob/en/latest/reference.html
关于environ字典和WebOb包的总结：https://www.jianshu.com/p/c62a4a2f5dd6

1.2WSGI Server

WSGI Server需要调用WSGI APP

def run(application):#服务器程序调用应用程序

    environ = {}#设定参数

    defstart_response(xxx):#设定参数

        pass

    result = application(environ, start_response)#调用APP的__call__函数（这里APP是一个类）

    def write(data):

        pass

    def data in result:#迭代访问

        write(data)

服务器程序主要做了以下的事：

  1\. 设定app所需要的参数(environ,start_response)

  2\. 调用app

  3\. 迭代访问app的返回结果(response body)，并传给客户端

但实际上已经有很多已经封装好的WSGI Server供我们使用，只需简单的将APP与一些其他的参数绑定来创建一个Server，而这个Server会将它接收到的request传递给绑定的APP。
如最简单，常用于实验环境中启动一个Server的方法，如下所示：

from paste import httpserver
def application(environ, start_response)
    pass

httpserver.serve(application, host = '127.0.0.1', port = 8080)

上面的方法是使用进程启动，一个进程对应一个服务（Server），对服务地启动、关闭、暂停都需要直接对进程进行操作，开销较大，而在OpenStack中，常用eventlet（绿色线程）来启动服务。

class Server(object)
  def __init__(self, app, host = '0.0.0.0', port = 0):
    #线程池，允许并行访问
    self._pool = eventlet.GreePool(10)
    #WSGI server的应用程序，由调用者传入！！！
    self.app = app
    #根据传入的参数创建监听socket
    self._socket = eventlet.listen((host, port), backlog = 10)
    #获取监听的地址和端口放到__dict__字典中，然后打印出来
    (self.host, self.port) = self._socket.getsockname()
    print("Listen on %(host)s:%(port)s" %self.__dict__)

  #start方法，由初始化的参数创建服务线程，注意需要传入app
  def start(self)
    self._server = eventlet.spawn(event.wsgi.server,
                                  self._socket
                                  self.app
                                  protocol = eventlet.wsgi.HttpProtocol,
                                  custom_pool = self._pool

  #stop方法，终止线程
  def stop(self):
    if self._server is not None:
       self._pool.resize(0)
       self._server.kill()

  #wait方法，监听http请求
  def wait(self):
    try:
      self._server.wait()
    except greenlet.GreeletExit:
      print("WSGI server has stopped.")

上面将WSGI Server封装到了一个Server类中，并通过传入WSGI APP参数创建Server实例来启动一个WSGI Server，但需要注意的是Server与APP并非简单的一对一或一对多的关系。

1.3WSGI Middleware

WSGI Middleware(中间件)是介于服务器程序和应用程序中间的部分，Middleware对Server和APP是透明的。
从实现上来说，Middleware和APP的输入和返回是一样的，只不过Middleware接收Server传递过来的request，经过自己的逻辑处理后（如路由，过滤），选择是调用下一个APP获取response返回或者直接返回response（如404，403等）。因此，Middleware就是中间APP。
Server获取到了客户端请求的URL，需要把URL交给不同的APP处理，这个功能可以使用Middleware实现：

# URL Routing middleware
def urlrouting(url_app_mapping):   
     def midware_app(environ, start_response):       #函数可调用，包含2个参数，返回可迭代的值
          url = environ['PATH_INFO']       
          app = url_app_mapping(url)       #获得对应url的应用程序
          result = app(environ, start_response)       #调用应用程序
          return result       
     return midware_app

函数midware_app就是Middleware（也是一个APP），调用流程：
1.实现一个url_app_mapping(url)函数，它传入url并返回请求的app
2.调用middleware_app = urlrouting(url_app_mapping)得到中间件app
3.使用middleware_app创建server

def url_app_mapping(url):
  pass

middleware_app = urlrouting(url_app_mapping)
server = make_server('ip',port,middleware_app)
server.serve_forever

Middleware 处于Server和APP之间，每个 Middleware 实现不同的功能，我们通常根据需求选择相应的 Middleware 并组合起来，实现所需的功能。其作用有以下几点：
• 根据 url 把用户请求调度到不同的 application 中。
• 负载均衡，转发用户请求
• 预处理 XSL 等相关数据
• 限制请求速率，设置白名单

未完待续。。。