Add "markdown" path.

handlers.go

diff --git a/handlers.go b/handlers.go
index c0d11a9..8c69ec8 100644
--- a/handlers.go
+++ b/handlers.go
@@ -55,6 +55,9 @@
 	if s.readyPath != "" {
 		h.mux.HandleFunc(s.readyPath, s.handleReady)
 	}
+	if s.markdownPath != "" {
+		h.mux.HandleFunc(s.markdownPath, s.handleMarkdown)
+	}
 	return h
 }
 
@@ -76,6 +79,11 @@
 handleHealth only fails if the user's health check function tells us.
 */
 func (s *HTTPScaffold) handleHealth(resp http.ResponseWriter, req *http.Request) {
+	if req.Method != "GET" {
+		resp.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
 	status, healthErr := s.callHealthCheck()
 
 	if status == Failed {
@@ -90,6 +98,11 @@
 tells us.
 */
 func (s *HTTPScaffold) handleReady(resp http.ResponseWriter, req *http.Request) {
+	if req.Method != "GET" {
+		resp.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
 	status, healthErr := s.callHealthCheck()
 	if status == OK {
 		healthErr = s.tracker.markedDown()
@@ -105,6 +118,22 @@
 	}
 }
 
+/*
+handleMarkdown handles a request to mark down the server.
+*/
+func (s *HTTPScaffold) handleMarkdown(resp http.ResponseWriter, req *http.Request) {
+	if req.Method != s.markdownMethod {
+		resp.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	req.Body.Close()
+	s.tracker.markDown()
+	if s.markdownHandler != nil {
+		s.markdownHandler()
+	}
+}
+
 func writeUnavailable(
 	resp http.ResponseWriter, req *http.Request,
 	stat HealthStatus, err error) {

scaffold.go

diff --git a/scaffold.go b/scaffold.go
index 1a07320..cc64cc1 100644
--- a/scaffold.go
+++ b/scaffold.go
@@ -31,6 +31,11 @@
 var ErrManualStop = errors.New("Shutdown called")
 
 /*
+ErrMarkedDown is used after being marked down but before being shut down.
+*/
+var ErrMarkedDown = errors.New("Marked down")
+
+/*
 HealthStatus is a type of response from a health check.
 */
 type HealthStatus int
@@ -58,6 +63,15 @@
 type HealthChecker func() (HealthStatus, error)
 
 /*
+MarkdownHandler is a type of function that an user may implement in order to
+be notified when the server is marked down. The function may do anything
+it needs to do in response to a markdown request. However, markdown will
+proceed even if the function fails. In case the function takes a long time,
+the scaffold will always invoke it inside a new goroutine.
+*/
+type MarkdownHandler func()
+
+/*
 An HTTPScaffold provides a set of features on top of a standard HTTP
 listener. It includes an HTTP handler that may be plugged in to any
 standard Go HTTP server. It is intended to be placed before any other
@@ -73,6 +87,9 @@
 	healthCheck        HealthChecker
 	healthPath         string
 	readyPath          string
+	markdownPath       string
+	markdownMethod     string
+	markdownHandler    MarkdownHandler
 }
 
 /*
@@ -155,6 +172,28 @@
 }
 
 /*
+SetMarkdown sets up a URI that will cause the server to mark it
+self down. However, this URI will not cause the server to actually shut
+down. Once any HTTP request is received on this path with a matching
+method, the server will be marked down. (the "readyPath" will respond
+with 503, and all other HTTP calls other than the "healthPath" will
+also respond with 503. The "healthPath" will still respond with 200.)
+If "handler" is not nil, the handler will be invoked and the API call
+will not return until the handler has returned. Because of that, the
+handler should return in a timely manner. (For instance, it should return
+in less than 30 seconds if Kubernetes is used unless the "grace period"
+is extended.)
+This makes this function the right thing to use
+as a "preStop" method in Kubernetes, so that the server can take action
+after shutdown to indicate that it has been deleted on purpose.
+*/
+func (s *HTTPScaffold) SetMarkdown(method, path string, handler MarkdownHandler) {
+	s.markdownPath = path
+	s.markdownMethod = method
+	s.markdownHandler = handler
+}
+
+/*
 SetHealthChecker specifies a function that the scaffold will call every time
 "HealthPath" or "ReadyPath" is invoked.
 */

scaffold_test.go

diff --git a/scaffold_test.go b/scaffold_test.go
index e4fe194..4a82a62 100644
--- a/scaffold_test.go
+++ b/scaffold_test.go
@@ -6,6 +6,7 @@
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"strings"
 	"sync/atomic"
 	"time"
 
@@ -123,6 +124,60 @@
 		}, time.Second).Should(BeFalse())
 	})
 
+	It("Markdown", func() {
+		var markedDown int32
+
+		s := CreateHTTPScaffold()
+		s.SetHealthPath("/health")
+		s.SetReadyPath("/ready")
+		s.SetMarkdown("POST", "/markdown", func() {
+			atomic.StoreInt32(&markedDown, 1)
+		})
+
+		stopChan := make(chan error)
+		err := s.Open()
+		Expect(err).Should(Succeed())
+
+		go func() {
+			listenErr := s.Listen(&testHandler{})
+			stopChan <- listenErr
+		}()
+
+		// Just make sure server is listening
+		Eventually(func() bool {
+			return testGet(s, "")
+		}, 5*time.Second).Should(BeTrue())
+
+		// Ensure that we are healthy and ready
+		code, _ := getText(fmt.Sprintf("http://%s/health", s.InsecureAddress()))
+		Expect(code).Should(Equal(200))
+		code, _ = getText(fmt.Sprintf("http://%s/ready", s.InsecureAddress()))
+		Expect(code).Should(Equal(200))
+
+		// Mark the server down, but don't stop it
+		resp, err := http.Post(fmt.Sprintf("http://%s/markdown", s.InsecureAddress()),
+			"text/plain", strings.NewReader("Goodbye!"))
+		Expect(err).Should(Succeed())
+		resp.Body.Close()
+		Expect(resp.StatusCode).Should(Equal(200))
+
+		// Server should immediately be marked down, not ready, but healthy
+		Expect(atomic.LoadInt32(&markedDown)).Should(BeEquivalentTo(1))
+		code, _ = getText(fmt.Sprintf("http://%s", s.InsecureAddress()))
+		Expect(code).Should(Equal(503))
+		code, _ = getText(fmt.Sprintf("http://%s/ready", s.InsecureAddress()))
+		Expect(code).Should(Equal(503))
+		code, _ = getText(fmt.Sprintf("http://%s/health", s.InsecureAddress()))
+		Expect(code).Should(Equal(200))
+
+		// Server should not have stopped yet
+		Consistently(stopChan).ShouldNot(Receive())
+
+		stopErr := errors.New("Test stop")
+		s.Shutdown(stopErr)
+		Eventually(stopChan).Should(Receive(Equal(stopErr)))
+	})
+
 	It("Health Check Functions", func() {
 		status := int32(OK)
 		var healthErr = &atomic.Value{}

tracker.go

diff --git a/tracker.go b/tracker.go
index 0f9c9ea..72e1b69 100644
--- a/tracker.go
+++ b/tracker.go
@@ -16,6 +16,15 @@
 )
 
 /*
+values for the shutdown state
+*/
+const (
+	running    int32 = iota
+	markedDown int32 = iota
+	shutDown   int32 = iota
+)
+
+/*
 The requestTracker keeps track of HTTP requests. In normal operations it
 just counts. Once the server has been marked for shutdown, however, it
 counts down to zero and returns a shutdown indication when that
@@ -26,7 +35,7 @@
 	// If "shutdown" is never called then this will never happen.
 	C              chan error
 	shutdownWait   time.Duration
-	shuttingDown   int32
+	shutdownState  int32
 	shutdownReason *atomic.Value
 	commandChan    chan int
 }
@@ -40,6 +49,7 @@
 	rt := &requestTracker{
 		C:              make(chan error, 1),
 		commandChan:    make(chan int, 100),
+		shutdownState:  running,
 		shutdownWait:   shutdownWait,
 		shutdownReason: &atomic.Value{},
 	}
@@ -74,8 +84,8 @@
 "Shutdown" method.
 */
 func (t *requestTracker) markedDown() error {
-	sd := atomic.LoadInt32(&t.shuttingDown)
-	if sd != 0 {
+	ss := atomic.LoadInt32(&t.shutdownState)
+	if ss != running {
 		reason := t.shutdownReason.Load().(*error)
 		if reason == nil {
 			return nil
@@ -95,6 +105,11 @@
 	t.commandChan <- shutdown
 }
 
+func (t *requestTracker) markDown() {
+	t.shutdownReason.Store(&ErrMarkedDown)
+	atomic.StoreInt32(&t.shutdownState, markedDown)
+}
+
 func (t *requestTracker) sendStop(sent bool) bool {
 	if !sent {
 		reason := t.shutdownReason.Load().(*error)
@@ -128,7 +143,7 @@
 				}
 			case shutdown:
 				stopping = true
-				atomic.StoreInt32(&t.shuttingDown, 1)
+				atomic.StoreInt32(&t.shutdownState, shutDown)
 				if activeRequests <= 0 {
 					sentStop = t.sendStop(sentStop)
 				} else {