package avatar import ( "crypto/md5" "encoding/hex" "errors" "fmt" "image" "image/jpeg" "image/png" "io" "log" "net/http" "net/url" "os" "path/filepath" "strings" "sync" "time" "github.com/nfnt/resize" ) var ( gravatar = "http://www.gravatar.com/avatar" defaultImagePath = "./default.jpg" ) // hash email to md5 string func HashEmail(email string) string { h := md5.New() h.Write([]byte(strings.ToLower(email))) return hex.EncodeToString(h.Sum(nil)) } type Avatar struct { Hash string cacheDir string // image save dir reqParams string imagePath string expireDuration time.Duration } func New(hash string, cacheDir string) *Avatar { return &Avatar{ Hash: hash, cacheDir: cacheDir, expireDuration: time.Minute * 10, reqParams: url.Values{ "d": {"retro"}, "size": {"200"}, "r": {"pg"}}.Encode(), imagePath: filepath.Join(cacheDir, hash+".image"), //maybe png or jpeg } } func (this *Avatar) InCache() bool { fileInfo, err := os.Stat(this.imagePath) return err == nil && fileInfo.Mode().IsRegular() } func (this *Avatar) Modtime() (modtime time.Time, err error) { fileInfo, err := os.Stat(this.imagePath) if err != nil { return } return fileInfo.ModTime(), nil } func (this *Avatar) Expired() bool { if !this.InCache() { return true } fileInfo, err := os.Stat(this.imagePath) return err != nil || time.Since(fileInfo.ModTime()) > this.expireDuration } // default image format: jpeg func (this *Avatar) Encode(wr io.Writer, size int) (err error) { var img image.Image decodeImageFile := func(file string) (img image.Image, err error) { fd, err := os.Open(file) if err != nil { return } defer fd.Close() img, err = jpeg.Decode(fd) if err != nil { fd.Seek(0, os.SEEK_SET) img, err = png.Decode(fd) } return } imgPath := this.imagePath if !this.InCache() { imgPath = defaultImagePath } img, err = decodeImageFile(imgPath) if err != nil { return } m := resize.Resize(uint(size), 0, img, resize.Lanczos3) return jpeg.Encode(wr, m, nil) } // get image from gravatar.com func (this *Avatar) Update() { thunder.Fetch(gravatar+"/"+this.Hash+"?"+this.reqParams, this.imagePath) } func (this *Avatar) UpdateTimeout(timeout time.Duration) error { var err error select { case <-time.After(timeout): err = errors.New("get gravatar image timeout") case err = <-thunder.GoFetch(gravatar+"/"+this.Hash+"?"+this.reqParams, this.imagePath): } return err } func init() { log.SetFlags(log.Lshortfile | log.LstdFlags) } // http.Handle("/avatar/", avatar.HttpHandler("./cache")) func HttpHandler(cacheDir string) func(w http.ResponseWriter, r *http.Request) { MustInt := func(r *http.Request, defaultValue int, keys ...string) int { var v int for _, k := range keys { if _, err := fmt.Sscanf(r.FormValue(k), "%d", &v); err == nil { defaultValue = v } } return defaultValue } return func(w http.ResponseWriter, r *http.Request) { urlPath := r.URL.Path hash := urlPath[strings.LastIndex(urlPath, "/")+1:] hash = HashEmail(hash) size := MustInt(r, 80, "s", "size") // size = 80*80 avatar := New(hash, cacheDir) if avatar.Expired() { err := avatar.UpdateTimeout(time.Millisecond * 500) if err != nil { log.Println(err) } } if modtime, err := avatar.Modtime(); err == nil { etag := fmt.Sprintf("size(%d)", size) if t, err := time.Parse(http.TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modtime.Before(t.Add(1*time.Second)) && etag == r.Header.Get("If-None-Match") { h := w.Header() delete(h, "Content-Type") delete(h, "Content-Length") w.WriteHeader(http.StatusNotModified) return } w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat)) w.Header().Set("ETag", etag) } w.Header().Set("Content-Type", "image/jpeg") err := avatar.Encode(w, size) if err != nil { log.Println(err) w.WriteHeader(500) } } } func init() { http.HandleFunc("/", HttpHandler("./")) log.Fatal(http.ListenAndServe(":8001", nil)) } var thunder = &Thunder{QueueSize: 10} type Thunder struct { QueueSize int // download queue size q chan *thunderTask once sync.Once } func (t *Thunder) init() { if t.QueueSize < 1 { t.QueueSize = 1 } t.q = make(chan *thunderTask, t.QueueSize) for i := 0; i < t.QueueSize; i++ { go func() { for { task := <-t.q task.Fetch() } }() } } func (t *Thunder) Fetch(url string, saveFile string) error { t.once.Do(t.init) task := &thunderTask{ Url: url, SaveFile: saveFile, } task.Add(1) t.q <- task task.Wait() return task.err } func (t *Thunder) GoFetch(url, saveFile string) chan error { c := make(chan error) go func() { c <- t.Fetch(url, saveFile) }() return c } // thunder download type thunderTask struct { Url string SaveFile string sync.WaitGroup err error } func (this *thunderTask) Fetch() { this.err = this.fetch() this.Done() } var client = &http.Client{} func (this *thunderTask) fetch() error { log.Println("thunder, fetch", this.Url) req, _ := http.NewRequest("GET", this.Url, nil) req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8") req.Header.Set("Accept-Encoding", "gzip,deflate,sdch") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.8") req.Header.Set("Cache-Control", "no-cache") req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.154 Safari/537.36") resp, err := client.Do(req) if err != nil { return err } defer resp.Body.Close() if resp.StatusCode != 200 { return fmt.Errorf("status code: %d", resp.StatusCode) } /* log.Println("headers:", resp.Header) switch resp.Header.Get("Content-Type") { case "image/jpeg": this.SaveFile += ".jpeg" case "image/png": this.SaveFile += ".png" } */ /* imgType := resp.Header.Get("Content-Type") if imgType != "image/jpeg" && imgType != "image/png" { return errors.New("not png or jpeg") } */ tmpFile := this.SaveFile + ".part" // mv to destination when finished fd, err := os.Create(tmpFile) if err != nil { return err } _, err = io.Copy(fd, resp.Body) fd.Close() if err != nil { os.Remove(tmpFile) return err } return os.Rename(tmpFile, this.SaveFile) }