cookie管理(3) 应用

// +build ignore
package main

import (
    "fmt"
    "html/template"
    "log"
    "net/http"
    "os"
    "path"
    "sync"
    "time"
    "xapp/components/httpmod/http"
    "xapp/components/httpmod/http/session"
    "xapp/components/httpmod/http/session/memory"
    "xapp/kore"
    utils "xapp/utils"
)

var (
    globalSessions *session.Manager
)

func getPagePath(name string) string {
    xappPath := os.Getenv("XAPP")
    return path.Join(xappPath, "components", "httpmod", "http", "ejemplo", name)
}

func init() {
    var err error
    memoryprovider.DoRegister()
    globalSessions, err = session.NewManager("memory", "gosessionid", 60*1000)
    globalSessions.DoStartGC()
    if err != nil {
        panic(err)
    }
    log.Println("global sessions is initialized")
}

func getString(session session.Session, key interface{}) string {
    rv := session.Get(key)
    if rv != nil {
        switch rv.(type) {
        case string:
            return rv.(string)
        }
    }
    return ""
}

func getBool(session session.Session, key interface{}, defVal bool) bool {
    rv := session.Get(key)
    if rv != nil {
        switch rv.(type) {
        case bool:
            return rv.(bool)
        }
    }
    return defVal
}

func doLogin(writer http.ResponseWriter, req *http.Request) {
    log.Printf("Login<%s>: Method = %s", req.URL.Path[1:], req.Method)
    sess := globalSessions.SessionStart(writer, req)
    req.ParseForm()
    log.Printf("Forms: %s", req.Form) // a proper map
    switch req.Method {
    case "GET":
        t, _ := template.ParseFiles(getPagePath("login.gtpl"))
        writer.Header().Set("Content-Type", "text/html")
        t.Execute(writer, nil)
    case "POST":
        if req.FormValue("username") == "cartman" && req.FormValue("password") == "poder" {
            sess.Set("login", true)
            sess.Set("tunombre", req.FormValue("username"))
            //http.Redirect(writer, req, "/logon", http.StatusFound)
            //break
            writer.Header().Set("Content-Type", "text/plain")
            fmt.Fprintf(writer, "logon")
            log.Printf("session-id:(logged in): %v", sess.SessionID())
        } else {
            // log.Println("try redirect")
            // http.Redirect(writer, req, "/countnow", http.StatusFound)
            writer.Header().Set("Content-Type", "text/plain")
            fmt.Fprintf(writer, "failed")
        }
    }
}

func genDoShutdown(doClose func()) func(writer http.ResponseWriter, req *http.Request) {
    return func(writer http.ResponseWriter, req *http.Request) {
        sess := globalSessions.SessionStart(writer, req)
        log.Printf("shutdown: %v", sess.SessionID())
        if getBool(sess, "login", false) {
            time.AfterFunc(0, doClose)
            writer.Header().Set("Content-Type", "text/plain")
            fmt.Fprintf(writer, "ok")
            return
        }
        writer.Header().Set("Content-Type", "text/plain")
        fmt.Fprintf(writer, "permission denied")
    }
}

func doLogon(w http.ResponseWriter, req *http.Request) {
    t, e1 := template.ParseFiles(getPagePath("logon.gtpl"))
    if e1 != nil {
        panic(e1)
    }
    type Info struct {
        Username string
        LoggedIn bool
    }
    sess := globalSessions.SessionStart(w, req)
    guessedName := getString(sess, "tunombre")
    log.Printf("Logon: welcome to <%v>", guessedName)
    t.Execute(w, &Info{
        Username: getString(sess, "tunombre"),
        LoggedIn: getBool(sess, "login", false),
    })
}

func doCount(w http.ResponseWriter, r *http.Request) {
    sess := globalSessions.SessionStart(w, r)
    createtime := sess.Get("createtime")
    if createtime == nil {
        sess.Set("createtime", time.Now().Unix())
    } else if (createtime.(int64)*1000 + 1000) < time.Now().Unix()*1000 {
        log.Println("createtime to !")
        globalSessions.SessionDestroy(w, r)
        sess = globalSessions.SessionStart(w, r)
    }
    ct := sess.Get("countnum")
    //log.Println("now count is:", ct)
    if ct == nil {
        sess.Set("countnum", 1)
    } else {
        sess.Set("countnum", (ct.(int) + 1))
    }
    t, _ := template.ParseFiles(getPagePath("count.gtpl"))
    w.Header().Set("Content-Type", "text/html")
    type Info struct {
        Count int
    }
    t.Execute(w, &Info{
        Count: sess.Get("countnum").(int),
    })
}

type runNow struct {
    wg       *sync.WaitGroup
    closeSig chan bool
}

func newRunNow(wg *sync.WaitGroup) *runNow {
    return &runNow{
        wg:       wg,
        closeSig: make(chan bool),
    }
}

func (r *runNow) StartServ() {
    r.wg.Add(1)
    go func() {
        defer r.wg.Done()
        tick := time.Tick(2 * time.Second)
    A100:
        for {
            select {
            case <-r.closeSig:
                log.Print("Stopped by user")
                break A100
            case <-tick:
                //log.Print("tick tac toc")
                break
            }
        }
        log.Print("leaving run-now")
    }()
}

func (r *runNow) StopServ() {
    r.closeSig <- true
}

func main() {
    var wg sync.WaitGroup
    man := kore.NewKMan()
    shutSig := make(chan bool, 1)
    sb := utils.MakeSysTouchExtra(shutSig)
    serverM := httpmodule.NewHttpSvrMod(10011, "TestSvr", &wg)
    mux := serverM.GetMux()
    //log.Printf("mux is %v", mux)
    mux.HandleFunc("/login", doLogin)
    mux.HandleFunc("/shutdown", genDoShutdown(func() {
        shutSig <- true
    }))

    //mux.HandleFunc("/countnow", doCount)
    //mux.HandleFunc("/logon", doLogon)
    //mux.HandleFunc("/loginnow", login)  // It will trigger exception
    man.AddMod(serverM)
    man.AddMod(newRunNow(&wg))

    man.Start()
    sb.Wait()
    man.Stop()
    wg.Wait()
    log.Println("end of test")
}