Architecture Overview
=====================

A software architecture is an abstraction of the run-time elements of
a software system during some phase of its operation. A system may be
composed of many levels of abstraction and many phases of operation,
each with its own software architecture.  Each abstraction is,
essentially, an artificial view of system behavior in which the
within-element behavior is hidden from view in order to concentrate
on the interaction among the elements at the chosen level of abstraction.

In other words, splitting up the design in terms of independent
software architectures makes it easier to reduce the scope of what
we are talking about for the whole system to only those things that
we need to talk about for each independent architecture, which in
turn helps us divide and conquer the work.

The existing Apache httpd architectures are pretty well described by
the Apache Modeling Project at

  http://www.fmc-modeling.org/projects/apache/index.php

and I would use their stencils if I had access to Visio 2003.
Plain text will have to do for now.

Server software has a fairly well-understood set of operative phases
(startup, run, restart, shutdown) each with its own set of sequential
tasks that can be considered sub-phases:

 OWNER          |  PARENT                    |  WORKER
                |                            |
 edit config    |                            |
                |                            |
 start server   |  startup                   |
                |    main invocation         |
                |    read system config      |
                |    set shared data         |
                |    init workers            |  startup
                |    enter run phase         |    read worker config
                |                            |    check for shutdown
                |  run                       |    listen/wait
                |    loop                    |
                |      set shared data       |  run
                |      monitor workers       |    accept connection
                |    until signal            |    loop
                |                            |      read request
 check status   |                            |      send response
                |                            |    while keepalive
                |                            |    close connection
 graceful       |  restart                   |
 restart        |    set worker shutdown     |  shutdown
                |    pipe of death?          |    run cleanups?
                |                            |    exit
 stop server    |  shutdown                  |
                |    set worker shutdown     |
                |    pipe of death?          |
                |    wait for workers        |
                |    kill remaining workers  |
                |    run cleanups            |


That's just a broad overview -- if you can think of other phases,
feel free to add them.  The rest of the files in this directory
attempt to address each of these architectures, and whatever others
we think of along the way.