Fragment Description:



Various type of handlers.
Either create thanks to Handle or HandleFunc, Different Types and the ServeHTTP enabler.
And http.FileServer(http.Dir()) to serve Files fom your disk Use of:
flag, expvar, sync.Mutex and time.

setOfHTTPexamplesInOne

Last update, on 2015, Fri 9 Oct, 16:15:40

/* ... <== see fragment description ... */

package main

import (
    "bytes"
    "expvar"
    "flag"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strconv"
    "sync"
    "time"
)

// hello world, the web server
var helloRequests = expvar.NewInt("hello-requests")

func HelloServer(w http.ResponseWriter, req *http.Request) {
    helloRequests.Add(1)
    io.WriteString(w, "<feed xmlns=\"http://www.w3.org/2005/Atom\"><title>https://golang.org/</title>    <subtitle>gofragments examples</subtitle></feed>\n")
}

// Simple counter server. POSTing to it will set the value.
type Counter struct {
    mu sync.Mutex // protects n
    n  int
}

// This makes Counter satisfy the expvar.Var interface, so we can export
// it directly.
func (ctr *Counter) String() string {
    ctr.mu.Lock()
    defer ctr.mu.Unlock()
    return fmt.Sprintf("%d", ctr.n)
}

// Dealing with GET or POST Request methods.
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    ctr.mu.Lock()
    defer ctr.mu.Unlock()
    switch req.Method {
    case "GET":
        ctr.n++
    case "POST":
        buf := new(bytes.Buffer)
        io.Copy(buf, req.Body)
        body := buf.String()
        if n, err := strconv.Atoi(body); err != nil {
            fmt.Fprintf(w, "bad POST: %v\nbody: [%v]\n", err, body)
        } else {
            ctr.n = n
            fmt.Fprint(w, "counter reset\n")
        }
    }
    fmt.Fprintf(w, "counter = %d\n", ctr.n)
}

// simple flag server
var booleanflag = flag.Bool("boolean", true, "another flag for testing")

func FlagServer(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprint(w, "Flags:\n")
    flag.VisitAll(func(f *flag.Flag) {
        if f.Value.String() != f.DefValue {
            fmt.Fprintf(w, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
        } else {
            fmt.Fprintf(w, "%s = %s\n", f.Name, f.Value.String())
        }
    })
}

// simple argument server
func ArgServer(w http.ResponseWriter, req *http.Request) {
    for _, s := range os.Args {
        fmt.Fprint(w, s, " ")
    }
}

// a channel (just for the fun of it)
type Chan chan int

func ChanCreate() Chan {
    c := make(Chan)
    go func(c Chan) {
        for x := 0; ; x++ {
            c <- x
        }
    }(c)
    return c
}
func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    io.WriteString(w, fmt.Sprintf("channel send #%d\n", <-ch))
}

// exec a program, redirecting output
func DateServer(rw http.ResponseWriter, req *http.Request) {
    rw.Header().Set("Content-Type", "text/plain; charset=utf-8")
    // date, err := exec.Command("/bin/date").Output()
    // if err != nil {
    // http.Error(rw, err.Error(), 500)
    // return
    // }
    // The reference time used in the layouts is:
    // Mon Jan 2 15:04:05 MST 2006
    date := time.Now().Format("Mon, 15:04 - Jan 2 2006 - London.")
    rw.Write([]byte(date))
}
func Logger(w http.ResponseWriter, req *http.Request) {
    log.Printf("the page: \"%v\" was not found.", req.URL)
    http.Error(w, "oops, that page cannot be found!", 404)
}

var webroot = flag.String("root", os.Getenv("HOME"), "web root directory")

func main() {
    flag.Parse()
    // The counter is published as a variable directly.
    ctr := new(Counter)
    expvar.Publish("counter", ctr)
    http.Handle("/counter", ctr)
    http.Handle("/", http.HandlerFunc(Logger))
    http.Handle("/go/", http.StripPrefix("/go/", http.FileServer(http.Dir(*webroot))))
    http.Handle("/chan", ChanCreate())
    http.HandleFunc("/flags", FlagServer)
    http.HandleFunc("/args", ArgServer)
    http.HandleFunc("/go/hello", HelloServer)
    http.HandleFunc("/date", DateServer)
    log.Println(" -- Listen and Serve on localhost:12345 -->")
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        log.Panicln("ListenAndServe:", err)
    }
}

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.



Comments