对pipe downstream的思考&分析

　　   回到ngx_http_upstream_send_response，如果是buffering，就会进入后面的处理过程，准备一个ngx_event_pipe_t结构的数据，这个结构可以通过upstream的u->pipe进行索引找到。首先设置p->output_filter输出过滤函数为ngx_http_output_filter，用来进行输出过滤并发送数据；将p->upstream 设置为跟后端 u->peer.connection; p->downstream设置为跟客户端的连接；

　　之后便是拷贝了u->buffer到p->preread_bufs，这个u->buf是读取上游返回的数据的缓冲区，也就是proxy；这里面有http头部，也可能有body部分；然后便是设置upstream的读回调函数read_event_handler为read_event_handler，跟客户端的连接的写回调函数write_event_handler为ngx_http_upstream_process_downstream；这2个回调函数一个处理跟upstream的读取数据，一个处理跟客户端连接的发送数据，这是重点。设置完后就调用ngx_http_upstream_process_upstream尝试读取upstream的数据。

  p = u->pipe;
    //设置filter，可以看到就是http的输出filter
    p->output_filter = ngx_http_upstream_output_filter;
    p->output_ctx = r;
    p->tag = u->output.tag;
    p->bufs = u->conf->bufs;//设置bufs，它就是upstream中设置的bufs.u == &flcf->upstream;
    p->busy_size = u->conf->busy_buffers_size;
    p->upstream = u->peer.connection;//赋值跟后端upstream的连接。
    p->downstream = c;//赋值跟客户端的连接。
    p->pool = r->pool;
    p->log = c->log;
    p->limit_rate = u->conf->limit_rate;
    p->start_sec = ngx_time();

    p->cacheable = u->cacheable || u->store;
-------------------------------------------------------
 //下面申请一个缓冲链接节点，来存储刚才我们再读取后端的包，为了得到HTTP headers的时候不小心多读取到的数据。
        //其实只要FCGI等后端发给后端的包中，有一个包的前半部分是header,后一部分是body，就会有预读数据。

    p->preread_bufs = ngx_alloc_chain_link(r->pool);
    if (p->preread_bufs == NULL) {
        ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
        return;
    }
    p->preread_bufs->buf = &u->buffer;
    p->preread_bufs->next = NULL;
    u->buffer.recycled = 1;
    p->preread_size = u->buffer.last - u->buffer.pos;
------------------------------------------
ngx_http_upstream_process_upstream

ngx_http_upstream_process_upstream 用来读取后端cgi等数据，然后调用pipe转发到客户端；下面来看看ngx_event_pipe。

/*在有buffering的时候，使用event_pipe进行数据的转发，调用 ngx_event_pipe_*
函数读取数据，或者发送数据给客户端。
ngx_event_pipe将upstream响应发送回客户端。do_write代表是否要往客户端发送，写数据。
如果设置了，那么会先发给客户端，再读upstream数据，当然，如果读取了数据，也会调用这里的。
*/
ngx_int_t
ngx_event_pipe(ngx_event_pipe_t *p, ngx_int_t do_write)
{
    ngx_int_t     rc;
    ngx_uint_t    flags;
    ngx_event_t  *rev, *wev;
//不断的用ngx_event_pipe_read_upstream读取客户端数据，然后调用ngx_event_pipe_write_to_downstream
    for ( ;; ) {
        if (do_write) {
            p->log->action = "sending to client";

            rc = ngx_event_pipe_write_to_downstream(p);

            if (rc == NGX_ABORT) {
                return NGX_ABORT;
            }

            if (rc == NGX_BUSY) {
                return NGX_OK;
            }
        }

        p->read = 0;
        p->upstream_blocked = 0;

        p->log->action = "reading upstream";
        //从upstream读取数据到chain的链表里面，然后整块整块的调用input_filter进行协议的解析，
        //并将HTTP结果存放在p->in，p->last_in的链表里面。
        if (ngx_event_pipe_read_upstream(p) == NGX_ABORT) {
            return NGX_ABORT;
        }
        //upstream_blocked是在ngx_event_pipe_read_upstream里面设置的变量,代表是否有数据已经从upstream读取了
        if (!p->read && !p->upstream_blocked) {
            break;
        }
        //还要转发到后端。因为我这次读到了一些数据
        do_write = 1;
    }

    if (p->upstream->fd != (ngx_socket_t) -1) {
        rev = p->upstream->read;

        flags = (rev->eof || rev->error) ? NGX_CLOSE_EVENT : 0;

        if (ngx_handle_read_event(rev, flags) != NGX_OK) {
            return NGX_ABORT;
        }

        if (!rev->delayed) {
            if (rev->active && !rev->ready) {
                ngx_add_timer(rev, p->read_timeout);

            } else if (rev->timer_set) {
                ngx_del_timer(rev);
            }
        }
    }

    if (p->downstream->fd != (ngx_socket_t) -1
        && p->downstream->data == p->output_ctx)
    {
        wev = p->downstream->write;
        if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
            return NGX_ABORT;
        }

        if (!wev->delayed) {
            if (wev->active && !wev->ready) {
                ngx_add_timer(wev, p->send_timeout);

            } else if (wev->timer_set) {
                ngx_del_timer(wev);
            }
        }
    }

    return NGX_OK;
}

整体流程是：

ngx_process_cycle循环调用ngx_process_events_and_timers，后者调用ngx_epoll_process_events处理读写事件；
1.c->read->handler = ngx_http_upstream_handler()；SOCK连接最基础的读写回调handler，
2.u->read_event_handler = ngx_http_upstream_process_upstream()；
3.ngx_event_pipe()；
4.ngx_event_pipe_read_upstream() 进入主要读取处理函数。

ngx_event_pipe_read_upstream函数完成下面几个功能：

0.从preread_bufs，free_raw_bufs或者ngx_create_temp_buf寻找一块空闲的或部分空闲的内存；
1.调用p->upstream->recv_chain==ngx_readv_chain，用writev的方式读取FCGI的数据,填充chain。
2.对于整块buf都满了的chain节点调用input_filter(ngx_http_fastcgi_input_filter)进行upstream协议解析，比如FCGI协议，解析后的结果放入p->in里面；
3.对于没有填充满的buffer节点，放入free_raw_bufs以待下次进入时从后面进行追加。
4.当然了，如果对端发送完数据FIN了，那就直接调用input_filter处理free_raw_bufs这块数据

简单来说就是：设置fd 回调，事件被唤醒，循环进行数据读取、解析、保存、转发；然后根据业务场景需求 处理异常逻辑