from django.db import models
class GlossaryTerm(models.Model):
    """ Model for describing a glossary word (term) """
    term = models.CharField(max_length=1024)
    meaning = models.CharField(max_length=1024)
    meaning_html = models.CharField('Meaning with HTML markup',
                    max_length=4096, null=True, blank=True)
    example = models.CharField(max_length=4096, null=True, blank=True)
    # can be a ManyToManyField?
    domains = models.CharField(max_length=128, null=True, blank=True)
    notes = models.CharField(max_length=2048, null=True, blank=True)
    url = models.CharField('URL', max_length=2048, null=True, blank=True)
    name = models.ForeignKey('GlossarySource', verbose_name='Source', blank=True)
    def __unicode__(self):
        return self.term
    class Meta:
        unique_together = ('term', 'meaning', 'url')

from django.contrib import admin
admin.site.register(GlossaryTerm)
admin.site.register(GlossarySource)

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    data = 'some data'
    return render_template('index.html', **locals())

# chatserver.py
import socket
import select
import signal
import sys
from communication import send, receive
class ChatServer(object):
    """ Simple chat server using select """
    def serve(self):
        inputs = [self.server,sys.stdin]
        self.outputs = []
        while True:
                inputready,outputready,exceptready = select.select(inputs, self.outputs, [])
            for s in inputready:
                if s == self.server:
                    # handle the server socket
                    client, address = self.server.accept()
                    # Read the login name
                    cname = receive(client).split('NAME: ')[1]
                    # Compute client name and send back
                    self.clients += 1
                    send(client, 'CLIENT: ' + str(address[0]))
                    inputs.append(client)
                    self.clientmap[client] = (address, cname)
                    self.outputs.append(client)
                elif s == sys.stdin:
                    # handle standard input – the server exits 
                    junk = sys.stdin.readline()
		  break
                else:
                    # handle all other sockets
                    try:
                        data = receive(s)
                        if data:
                            # Send as new client's message...
                            msg = '\n#[' + self.get_name(s) + ']>> ' + data
                            # Send data to all except ourselves
                            for o in self.outputs:
                                if o != s:
                                    send(o, msg)
                        else:
                            print('chatserver: %d hung up' % s.fileno())
                            self.clients -= 1
                            s.close()
                            inputs.remove(s)
                            self.outputs.remove(s)
                    except socket.error as e:
                        # Remove
                        inputs.remove(s)
                        self.outputs.remove(s)
        self.server.close()
if __name__ == "__main__":
    ChatServer().serve()

# chatclient.py
import socket
import select
import sys
from communication import send, receive
class ChatClient(object):
    """ A simple command line chat client using select """
    def __init__(self, name, host='127.0.0.1', port=3490):
        self.name = name
        # Quit flag
        self.flag = False
        self.port = int(port)
        self.host = host
        # Initial prompt
        self.prompt='[' + '@'.join((name, socket.gethostname().split('.')[0])) + ']> '
        # Connect to server at port
        try:
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.sock.connect((host, self.port))
            print('Connected to chat server@%d' % self.port)
            # Send my name...
            send(self.sock,'NAME: ' + self.name) 
            data = receive(self.sock)
            # Contains client address, set it
            addr = data.split('CLIENT: ')[1]
            self.prompt = '[' + '@'.join((self.name, addr)) + ']> '
        except socket.error as e:
            print('Could not connect to chat server @%d' % self.port)
            sys.exit(1)
    def chat(self):
        """ Main chat method """
        while not self.flag:
            try:
                sys.stdout.write(self.prompt)
                sys.stdout.flush()
                # Wait for input from stdin & socket
                inputready, outputready,exceptrdy = select.select([0, self.sock], [],[])
                for i in inputready:
                    if i == 0:
                        data = sys.stdin.readline().strip()
                        if data: send(self.sock, data)
                    elif i == self.sock:
                        data = receive(self.sock)
                        if not data:
                            print('Shutting down.')
                            self.flag = True
                            break
                        else:
                            sys.stdout.write(data + '\n')
                            sys.stdout.flush()
            except KeyboardInterrupt:
                print('Interrupted.')
                self.sock.close()
                break
if __name__ == "__main__":
    if len(sys.argv)<3:
        sys.exit('Usage: %s chatid host portno' % sys.argv[0])
    client = ChatClient(sys.argv[1],sys.argv[2], int(sys.argv[3]))
    client.chat()

# communication.py
import pickle
import socket
import struct
def send(channel, *args):
    """ Send a message to a channel """
    buf = pickle.dumps(args)
    value = socket.htonl(len(buf))
    size = struct.pack("L",value)
    channel.send(size)
    channel.send(buf)
def receive(channel):
    """ Receive a message from a channel """
    size = struct.calcsize("L")
    size = channel.recv(size)
    try:
        size = socket.ntohl(struct.unpack("L", size)[0])
    except struct.error as e:
        return ''
    buf = ""
    while len(buf) < size:
        buf = channel.recv(size - len(buf))
    return pickle.loads(buf)[0]

while True:
    timeout = time_until_next_timed_event()
    events = wait_for_events(timeout)
    events += timed_events_until(now())
    for event in events:
        event.process()

# twisted_fetch_url.py
from twisted.internet import reactor
from twisted.web.client import getPage
import sys
def save_page(page, filename='content.html'):
    print type(page)
    open(filename,'w').write(page)
    print 'Length of data',len(page)
    print 'Data saved to',filename
def handle_error(error):
    print error
def finish_processing(value):
    print "Shutting down..."
    reactor.stop()
if __name__ == "__main__":
    url = sys.argv[1]
    deferred = getPage(url) 
    deferred.addCallbacks(save_page, handle_error)
    deferred.addBoth(finish_processing)
    reactor.run()

$ python2 twisted_fetch_url.py http://www.google.com
Length of data 13280
Data saved to content.html
Shutting down...

from twisted.internet import protocol, reactor
class Chat(protocol.Protocol):
    """ Chat protocol """
    transports = {}
    peers = {}
    def connectionMade(self):
        self._peer = self.transport.getPeer()
        print 'Connected',self._peer
    def connectionLost(self, reason):
        self._peer = self.transport.getPeer()
        # Find out and inform other clients
        user = self.peers.get((self._peer.host, self._peer.port))
        if user != None:
            self.broadcast('(User %s disconnected)\n' % user, user)
            print 'User %s disconnected from %s' % (user, self._peer)
    def broadcast(self, msg, user):
        """ Broadcast chat message to all connected users except 'user' """
        for key in self.transports.keys():
            if key != user:
                if msg != "<handshake>":
                    self.transports[key].write('#[' + user + "]>>> " + msg)
                else:
                    # Inform other clients of connection
                    self.transports[key].write('(User %s connected from %s)\n' % (user, self._peer))                
    def dataReceived(self, data):
        """ Callback when data is ready to be read from the socket """
        user, msg = data.split(":")
        print "Got data=>",msg,"from",user
        self.transports[user] = self.transport
        # Make an entry in the peers dictionary
        self.peers[(self._peer.host, self._peer.port)] = user
        self.broadcast(msg, user)
class ChatFactory(protocol.Factory):
    """ Chat protocol factory """
    def buildProtocol(self, addr):
        return Chat()
if __name__ == "__main__":
    reactor.listenTCP(3490, ChatFactory())
    reactor.run()

import sys
import socket
from twisted.internet import stdio, reactor, protocol
class ChatProtocol(protocol.Protocol):
    """ Base protocol for chat """
    def __init__(self, client):
        self.output = None
        # Client name: E.g: andy
        self.client = client
        self.prompt='[' + '@'.join((self.client, socket.gethostname().split('.')[0])) + ']> '             
    def input_prompt(self):
        """ The input prefix for client """
        sys.stdout.write(self.prompt)
        sys.stdout.flush()
    def dataReceived(self, data):
        self.processData(data)
class ChatClientProtocol(ChatProtocol):
    """ Chat client protocol """
    def connectionMade(self):
        print 'Connection made'
        self.output.write(self.client + ":<handshake>")
    def processData(self, data):
        """ Process data received """
        if not len(data.strip()):
            return
        self.input_prompt()
        if self.output:
            # Send data in this form to server
            self.output.write(self.client + ":" + data)
class StdioClientProtocol(ChatProtocol):
    """ Protocol which reads data from input and echoes
    data to standard output """
    def connectionMade(self):
        # Create chat client protocol
        chat = ChatClientProtocol(client=sys.argv[1])
        chat.output = self.transport
        # Create stdio wrapper
        stdio_wrapper = stdio.StandardIO(chat)
        # Connect to output
        self.output = stdio_wrapper
        print "Connected to server"
        self.input_prompt()
    def input_prompt(self):
        # Since the output is directly connected
        # to stdout, use that to write.
        self.output.write(self.prompt)
    def processData(self, data):
        """ Process data received """
        if self.output:
            self.output.write('\n' + data)
            self.input_prompt()
class StdioClientFactory(protocol.ClientFactory):
    def buildProtocol(self, addr):
        return StdioClientProtocol(sys.argv[1])
def main():
    reactor.connectTCP("localhost", 3490, StdioClientFactory())
    reactor.run()
if __name__ == '__main__':
    main()

# eventlet_chat.py
import eventlet
from eventlet.green import socket
participants = set()
def new_chat_channel(conn):
    """ New chat channel for a given connection """
    data = conn.recv(1024)
    user = ''
    while data:
        print("Chat:", data.strip())
        for p in participants:
            try:
                if p is not conn:
                    data = data.decode('utf-8')
                    user, msg = data.split(':')
                    if msg != '<handshake>':
                        data_s = '\n#[' + user + ']>>> says ' + msg
                    else:
                        data_s = '(User %s connected)\n' % user
                    p.send(bytearray(data_s, 'utf-8'))
            except socket.error as e:
                # ignore broken pipes, they just mean the participant
                # closed its connection already
                if e[0] != 32:
                    raise
        data = conn.recv(1024)
    participants.remove(conn)
    print("Participant %s left chat." % user)
if __name__ == "__main__":
    port = 3490
    try:
        print("ChatServer starting up on port", port)
        server = eventlet.listen(('0.0.0.0', port))
        while True:
            new_connection, address = server.accept()
            print("Participant joined chat.")
            participants.add(new_connection)
            print(eventlet.spawn(new_chat_channel,
                                 new_connection))
    except (KeyboardInterrupt, SystemExit):
        print("ChatServer exiting.")

# gevent_chat_server.py
import gevent
from gevent import monkey
from gevent import socket
from gevent.server import StreamServer
monkey.patch_all()
participants = set()
def new_chat_channel(conn, address):
    """ New chat channel for a given connection """
    participants.add(conn)
    data = conn.recv(1024)
    user = ''
    while data:
        print("Chat:", data.strip())
        for p in participants:
            try:
                if p is not conn:
                    data = data.decode('utf-8')
                    user, msg = data.split(':')
                    if msg != '<handshake>':
                        data_s = '\n#[' + user + ']>>> says ' + msg
                    else:
                        data_s = '(User %s connected)\n' % user
                    p.send(bytearray(data_s, 'utf-8'))                  
            except socket.error as e:
                # ignore broken pipes, they just mean the participant
                # closed its connection already
                if e[0] != 32:
                    raise
        data = conn.recv(1024)
    participants.remove(conn)
    print("Participant %s left chat." % user)
if __name__ == "__main__":
    port = 3490
    try:
        print("ChatServer starting up on port", port)
        server = StreamServer(('0.0.0.0', port), new_chat_channel)
        server.serve_forever()
    except (KeyboardInterrupt, SystemExit):
        print("ChatServer exiting.")

GET /restaurants?geohash=tdr1y1g1zgzc
    "8f95e6ad-17a7-48a9-9f82-07972d2bc660": {
        "name": "Tandoor",
        "address": "Centenary building, #28, MG Road b-01"
        "hours": "12.00 – 23.30"
  "4307a4b1-6f35-481b-915b-c57d2d625e93": {
        "name": "Karavalli",
        "address": "The Gateway Hotel, 66, Ground Floor"
        "hours": "12.30 – 01:00"
第二个服务返回餐厅元数据，主要返回 JSON，如下所示：
GET /restaurants/8f95e6ad-17a7-48a9-9f82-07972d2bc660
   "name": "Tandoor",
   "address": "Centenary building, #28, MG Road b-01"
   "hours": "12.00 – 23.30",
   "rating": 4.5,
   "cuisine": "north indian",
   "lunch buffet": "no",
   "dinner buffet": "no",
   "price": 800
下面是第三个的交互，它根据餐厅 ID 进行预订：
由于此服务需要用户提供预订信息，因此需要一个包含预订详细信息的 JSON 负载。因此，这最好作为 HTTP POST 调用来完成。
POST  /restaurants/reserve




    

在这种情况下，服务将使用以下给定有效负载作为 POST 数据：
   "name": "Anand B Pillai",
   "phone": 9880078014,
   "time": "2017-04-14 20:40:00",
   "seats": 3,
   "id": "8f95e6ad-17a7-48a9-9f82-07972d2bc660"
它将返回一个 JSON 作为响应，如下所示：
   "status": "confirmed",
   "code": "WJ7D2B",
   "time": "2017-04-14 20:40:00",
   "seats": 3
有了这种设计，在您选择的框架中实现应用并不困难，无论是 Flask、Bottle、Nameko 还是其他任何东西。
微服务——优势

那么，与单片应用相比，使用微服务有什么优势呢？让我们来看看一些重要的问题：
微服务通过将应用逻辑拆分为多个服务来增强关注点的分离。这提高了内聚性，减少了耦合。由于业务逻辑不在一个地方，因此不需要对系统进行自顶向下、预先的设计。相反，架构师可以专注于微服务和应用之间的相互作用和通信，并让微服务本身的设计和架构通过重构迭代地出现。
微服务提高了可测试性，因为现在逻辑的每个部分都可以作为一个单独的服务进行独立测试，因此很容易与其他部分隔离，并进行测试。
团队可以围绕业务能力而不是应用层或技术层来组织。由于每个微服务都包括逻辑、数据和部署，因此使用微服务的公司鼓励跨职能角色。这有助于建立一个更加敏捷的组织。
微服务鼓励分散数据。通常，每个服务都有自己的本地数据库或数据存储，而不是单一应用首选的中央数据库。
微服务促进了持续交付和集成以及快速部署。由于对业务逻辑的更改通常只需要对一个或几个服务进行小的更改，因此测试和重新部署通常可以在紧凑的周期内完成，并且在大多数情况下可以完全自动化。
管道和过滤器结构

管道和过滤器是一种简单的架构样式，它连接许多处理数据流的组件，每个组件通过管道连接到处理管道中的下一个组件。
管道和过滤器架构的灵感来自 Unix 技术，即通过外壳上的管道将应用的输出连接到另一个应用的输入。
管道和过滤器架构由一个或多个数据源组成。数据源通过管道连接到数据过滤器。过滤器处理接收到的数据，并将其传递给管道中的其他过滤器。最终数据在数据接收器接收：
管道和过滤器架构
管道和过滤器通常用于执行大量数据处理（如数据分析、数据转换、元数据提取等）的应用。
过滤器可以在同一台机器上运行，它们使用实际的 Unix 管道或共享内存进行通信。然而，在大型系统中，它们通常在单独的机器上运行，管道不需要是实际的管道，而是任何类型的数据通道，如套接字、共享内存、队列等。
可以将多个过滤器管道连接在一起，以执行复杂的数据处理和数据暂存。
使用这种架构的 Linux 应用的一个很好的例子是gstreamer——一个多媒体处理库，它可以对多媒体视频和音频执行许多任务，包括播放、录制、编辑和流媒体。
Python 中的管道和过滤器

在 Python 中，我们在多处理模块中遇到了最纯粹的管道。多处理模块提供管道作为从一个进程到另一个进程的通信方式。
管道将创建为一对父连接和子连接。连接一侧写的内容可以在另一侧读取，反之亦然。
这使我们能够构建非常简单的数据处理管道。
例如，在 Linux 上，可以通过以下一系列命令计算文件中的字数：
$ cat filename | wc -w
我们将编写一个简单的程序，使用多处理模块模拟此管道：
# pipe_words.py
from multiprocessing import Process, Pipe
import sys
def read(filename, conn):
    """ Read data from a file and send it to a pipe """
    conn.send(open(filename).read())
def words(conn):
    """ Read data from a connection and print number of words """
    data = conn.recv()
    print('Words',len(data.split()))
if __name__ == "__main__":
    parent, child = Pipe()
    p1 = Process(target=read, args=(sys.argv[1], child))
    p1.start()
    p2 = Process(target=words, args=(parent,))
    p2.start()
    p1.join();p2.join()
以下是对工作流程的分析：
将创建一个管道，并获得两个连接。
read函数作为一个进程执行，传递管道（子）的一端和要读取的文件名。
此进程读取文件，并将数据写入连接。
words函数作为第二个进程执行，将管道的另一端传递给它。
当此函数作为进程执行时，它从连接读取数据，并打印字数。
以下屏幕截图显示了同一文件上 shell 命令和前面程序的输出：
使用管道及其等效 Python 程序输出 shell 命令
创建管道不需要使用看起来像实际管道的对象。另一方面，Python 中的生成器提供了一种极好的方法来创建一组可调用项，这些可调用项彼此调用，并消费和处理彼此的数据，从而生成一条数据处理管道。
这是与上一个相同的示例，重写为使用生成器，这一次处理文件夹中与特定模式匹配的所有文件：
# pipe_words_gen.py
# A simple data processing pipeline using generators
# to print count of words in files matching a pattern.
import os
def read(filenames):
    """ Generator that yields data from filenames as (filename, data) tuple """
    for filename in filenames:
        yield filename, open(filename).read()
def words(input):
    """ Generator that calculates words in its input """
    for filename, data in input:
        yield filename, len(data.split())
def filter(input, pattern):
    """ Filter input stream according to a pattern """
    for item in input:
        if item.endswith(pattern):
            yield item
if __name__ == "__main__":
    # Source
    stream1 = filter(os.listdir('.'), '.py')
    # Piped to next filter
    stream2 = read(stream1)
    # Piped to last filter (sink)
    stream3 = words(stream2)
    for item in stream3:
        print(item)
以下是输出的屏幕截图：
使用生成器的管道输出，该生成器打印 Python 程序的字数
可以使用以下命令验证前一个程序的输出：
$ wc -w *.py
下面是另一个程序，它使用另外两个数据过滤生成器构建一个程序，该程序监视与特定模式匹配的文件，并打印有关最新文件的信息—类似于 Linux 上的监视程序所执行的操作：
# pipe_recent_gen.py
# Using generators, print details of the most recently modified file
# matching a pattern.
import glob
import os
from time import sleep
def watch(pattern):
    """ Watch a folder for modified files matching a pattern """
    while True:
        files = glob.glob(pattern)
        # sort by modified time
        files = sorted(files, key=os.path.getmtime)
        recent = files[-1]
        yield recent        
        # Sleep a bit
        sleep(1)
def get(input):
    """ For a given file input, print its meta data """
    for item in input:
        data = os.popen("ls -lh " + item).read()
        # Clear screen
        os.system("clear")
        yield data
if __name__ == "__main__":
    import sys
    # Source + Filter #1
    stream1 = watch('*.' + sys.argv[1])
    while True:
        # Filter #2 + sink
        stream2 = get(stream1)
        print(stream2.__next__())
        sleep(2)
这最后一个程序的细节应该对读者不言自明。
下面是我们的程序在控制台上的输出，监视 Python 源文件：
监视最近修改的 Python 源文件的程序的输出
如果我们创建一个空 Python 源文件，比如example.py，那么输出会在两秒钟内发生变化：
监视程序的输出更改，始终显示最近修改的文件
使用生成器（co 例程）构建此类管道的基本技术是将一个生成器的输出连接到下一个生成器的输入。通过将许多这样的生成器串联起来，可以构建复杂程度从简单到复杂的数据处理管道。
当然，除此之外，还可以使用多种技术来建造管道。一些常见的选择是使用队列连接的生产者-消费者任务，队列可以使用线程或进程。在关于可伸缩性的一章中，我们已经看到了这方面的例子。
微服务还可以通过将一个微服务的输入连接到另一个微服务的输出来构建简单的处理管道。
在 Python 第三方软件生态系统中，有许多模块和框架允许您构建复杂的数据管道。芹菜，虽然是一个任务队列，但可以用于构建简单的批处理工作流，但管道支持有限。流水线不是芹菜的强大特性，但它对可用于此目的的链接任务的支持有限。
Luigi 是另一个健壮的框架，它是为需要管道和过滤器架构的复杂、长期运行的批处理作业编写的。Luigi 内置了对 Hadoop 作业的支持，因此它是构建数据分析管道的好选择。
在本章中，我们介绍了构建软件的一些常见架构模式。我们从模型-视图-控制器架构开始，并查看了 Django 和 Flask 中的示例。您了解了 MVC 架构的组件，并了解到 Django 使用模板实现了 MVC 的一个变体。
我们将 Flask 视为一个微框架的示例，该框架通过使用带有附加服务的插件架构来实现 web 应用的最小占用空间。
我们接着讨论了事件驱动编程架构，它是一种使用共同例程和事件的异步编程。我们从一个使用 Python 中的select模块的多用户聊天示例开始。从那以后，我们继续讨论更大的框架和库。
我们讨论了 Twisted 的架构及其组件。我们还讨论了 Eventlet 及其近亲 gevent。对于这些框架中的每一个，我们都看到了多用户聊天服务器的实现。
接下来，我们将微服务作为一种架构，它通过在多个服务之间拆分核心业务逻辑来构建可伸缩的服务和部署。我们设计了一个使用微服务的餐厅预订应用的示例，并简要介绍了可用于构建微服务的 Python web 框架。
在本章末尾，我们看到了使用管道和过滤器进行串行和可伸缩数据处理的架构。我们使用 Python 中的多处理模块构建了一个实际管道的简单示例，该模块模仿 Unix 管道命令。然后，我们研究了使用发电机建造管道的技术，并看到了几个例子。我们总结了在 Python 第三方软件生态系统中构建管道和框架的技术。
这就把我们带到了应用架构一章的末尾。在下一章中，我们将介绍可部署性，即将软件部署到生产系统等环境的方面。