| Request Method: | {{.RequestMethod}} | +
| Request URL: | {{.RequestURL}} | +
| RemoteAddr: | {{.RemoteAddr }} | +
+ Stack
+
+ {{.Stack}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++For detail usage please check our document: +
++Toolbox +
++Live Monitor +
+{{.Content}} +{{end}}` + +var profillingTpl = ` +{{define "content"}} +++{{end}}` + +var defaultScriptsTpl = `` + +var gcAjaxTpl = ` +{{define "scripts"}} + +{{end}} +` + +var qpsTpl = `{{define "content"}} +{{.Content}}+
| + {{.}} + | + {{end}} +||||||
|---|---|---|---|---|---|---|
| {{index $elem 0}} | +{{index $elem 1}} | +{{index $elem 2}} | +{{index $elem 4}} | +{{index $elem 6}} | +{{index $elem 8}} | +{{index $elem 10}} | +
+{{range $index, $elem := .Content}}
+{{$index}}={{$elem}}
+{{end}}
+
+{{end}}
+`
+
+var routerAndFilterTpl = `{{define "content"}}
+
+
+| + {{.}} + | + {{end}} +
|---|
| + {{.}} + | + {{end}} +
| +{{.}} + | +{{end}} +|
|---|---|
| + {{.}} + | + {{end}} ++ Run + | +
| + {{.}} + | +{{end}} +|
|---|---|
| + {{$elem}} + | + {{end}} + {{end}} ++ {{$header}} + | +
+
+
+| Request Method: | {{.RequestMethod}} | +
| Request URL: | {{.RequestURL}} | +
| RemoteAddr: | {{.RemoteAddr }} | +
{{.Stack}}
+ This is SomeVar: {{ .SomeVar }}
+{{ end }} + +{{ define "js" }} + +{{ end}}` + +var layoutBlog = ` + + +This is SomeVar: val
+ +This is SomeVar: val
+ + +` + +func TestFsBinData(t *testing.T) { + SetTemplateFSFunc(func() http.FileSystem { + return TestingFileSystem{&assetfs.AssetFS{Asset: testdata.Asset, AssetDir: testdata.AssetDir, AssetInfo: testdata.AssetInfo}} + }) + dir := "views" + if err := AddViewPath("views"); err != nil { + t.Fatal(err) + } + beeTemplates := beeViewPathTemplates[dir] + if len(beeTemplates) != 3 { + t.Fatalf("should be 3 but got %v", len(beeTemplates)) + } + if err := beeTemplates["index.tpl"].ExecuteTemplate(os.Stdout, "index.tpl", map[string]string{"Title": "Hello", "SomeVar": "val"}); err != nil { + t.Fatal(err) + } + out := bytes.NewBufferString("") + if err := beeTemplates["index.tpl"].ExecuteTemplate(out, "index.tpl", map[string]string{"Title": "Hello", "SomeVar": "val"}); err != nil { + t.Fatal(err) + } + + if out.String() != outputBinData { + t.Log(out.String()) + t.Fatal("Compare failed") + } +} diff --git a/pkg/templatefunc.go b/pkg/templatefunc.go new file mode 100644 index 00000000..ba1ec5eb --- /dev/null +++ b/pkg/templatefunc.go @@ -0,0 +1,780 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package beego + +import ( + "errors" + "fmt" + "html" + "html/template" + "net/url" + "reflect" + "regexp" + "strconv" + "strings" + "time" +) + +const ( + formatTime = "15:04:05" + formatDate = "2006-01-02" + formatDateTime = "2006-01-02 15:04:05" + formatDateTimeT = "2006-01-02T15:04:05" +) + +// Substr returns the substr from start to length. +func Substr(s string, start, length int) string { + bt := []rune(s) + if start < 0 { + start = 0 + } + if start > len(bt) { + start = start % len(bt) + } + var end int + if (start + length) > (len(bt) - 1) { + end = len(bt) + } else { + end = start + length + } + return string(bt[start:end]) +} + +// HTML2str returns escaping text convert from html. +func HTML2str(html string) string { + + re := regexp.MustCompile(`\<[\S\s]+?\>`) + html = re.ReplaceAllStringFunc(html, strings.ToLower) + + //remove STYLE + re = regexp.MustCompile(`\This is SomeVar: {{ .SomeVar }}
+ + diff --git a/pkg/testing/assertions.go b/pkg/testing/assertions.go new file mode 100644 index 00000000..96c5d4dd --- /dev/null +++ b/pkg/testing/assertions.go @@ -0,0 +1,15 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package testing diff --git a/pkg/testing/client.go b/pkg/testing/client.go new file mode 100644 index 00000000..c3737e9c --- /dev/null +++ b/pkg/testing/client.go @@ -0,0 +1,65 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package testing + +import ( + "github.com/astaxie/beego/config" + "github.com/astaxie/beego/httplib" +) + +var port = "" +var baseURL = "http://localhost:" + +// TestHTTPRequest beego test request client +type TestHTTPRequest struct { + httplib.BeegoHTTPRequest +} + +func getPort() string { + if port == "" { + config, err := config.NewConfig("ini", "../conf/app.conf") + if err != nil { + return "8080" + } + port = config.String("httpport") + return port + } + return port +} + +// Get returns test client in GET method +func Get(path string) *TestHTTPRequest { + return &TestHTTPRequest{*httplib.Get(baseURL + getPort() + path)} +} + +// Post returns test client in POST method +func Post(path string) *TestHTTPRequest { + return &TestHTTPRequest{*httplib.Post(baseURL + getPort() + path)} +} + +// Put returns test client in PUT method +func Put(path string) *TestHTTPRequest { + return &TestHTTPRequest{*httplib.Put(baseURL + getPort() + path)} +} + +// Delete returns test client in DELETE method +func Delete(path string) *TestHTTPRequest { + return &TestHTTPRequest{*httplib.Delete(baseURL + getPort() + path)} +} + +// Head returns test client in HEAD method +func Head(path string) *TestHTTPRequest { + return &TestHTTPRequest{*httplib.Head(baseURL + getPort() + path)} +} diff --git a/pkg/toolbox/healthcheck.go b/pkg/toolbox/healthcheck.go new file mode 100644 index 00000000..e3544b3a --- /dev/null +++ b/pkg/toolbox/healthcheck.go @@ -0,0 +1,48 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package toolbox healthcheck +// +// type DatabaseCheck struct { +// } +// +// func (dc *DatabaseCheck) Check() error { +// if dc.isConnected() { +// return nil +// } else { +// return errors.New("can't connect database") +// } +// } +// +// AddHealthCheck("database",&DatabaseCheck{}) +// +// more docs: http://beego.me/docs/module/toolbox.md +package toolbox + +// AdminCheckList holds health checker map +var AdminCheckList map[string]HealthChecker + +// HealthChecker health checker interface +type HealthChecker interface { + Check() error +} + +// AddHealthCheck add health checker with name string +func AddHealthCheck(name string, hc HealthChecker) { + AdminCheckList[name] = hc +} + +func init() { + AdminCheckList = make(map[string]HealthChecker) +} diff --git a/pkg/toolbox/profile.go b/pkg/toolbox/profile.go new file mode 100644 index 00000000..06e40ede --- /dev/null +++ b/pkg/toolbox/profile.go @@ -0,0 +1,184 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package toolbox + +import ( + "fmt" + "io" + "log" + "os" + "path" + "runtime" + "runtime/debug" + "runtime/pprof" + "strconv" + "time" +) + +var startTime = time.Now() +var pid int + +func init() { + pid = os.Getpid() +} + +// ProcessInput parse input command string +func ProcessInput(input string, w io.Writer) { + switch input { + case "lookup goroutine": + p := pprof.Lookup("goroutine") + p.WriteTo(w, 2) + case "lookup heap": + p := pprof.Lookup("heap") + p.WriteTo(w, 2) + case "lookup threadcreate": + p := pprof.Lookup("threadcreate") + p.WriteTo(w, 2) + case "lookup block": + p := pprof.Lookup("block") + p.WriteTo(w, 2) + case "get cpuprof": + GetCPUProfile(w) + case "get memprof": + MemProf(w) + case "gc summary": + PrintGCSummary(w) + } +} + +// MemProf record memory profile in pprof +func MemProf(w io.Writer) { + filename := "mem-" + strconv.Itoa(pid) + ".memprof" + if f, err := os.Create(filename); err != nil { + fmt.Fprintf(w, "create file %s error %s\n", filename, err.Error()) + log.Fatal("record heap profile failed: ", err) + } else { + runtime.GC() + pprof.WriteHeapProfile(f) + f.Close() + fmt.Fprintf(w, "create heap profile %s \n", filename) + _, fl := path.Split(os.Args[0]) + fmt.Fprintf(w, "Now you can use this to check it: go tool pprof %s %s\n", fl, filename) + } +} + +// GetCPUProfile start cpu profile monitor +func GetCPUProfile(w io.Writer) { + sec := 30 + filename := "cpu-" + strconv.Itoa(pid) + ".pprof" + f, err := os.Create(filename) + if err != nil { + fmt.Fprintf(w, "Could not enable CPU profiling: %s\n", err) + log.Fatal("record cpu profile failed: ", err) + } + pprof.StartCPUProfile(f) + time.Sleep(time.Duration(sec) * time.Second) + pprof.StopCPUProfile() + + fmt.Fprintf(w, "create cpu profile %s \n", filename) + _, fl := path.Split(os.Args[0]) + fmt.Fprintf(w, "Now you can use this to check it: go tool pprof %s %s\n", fl, filename) +} + +// PrintGCSummary print gc information to io.Writer +func PrintGCSummary(w io.Writer) { + memStats := &runtime.MemStats{} + runtime.ReadMemStats(memStats) + gcstats := &debug.GCStats{PauseQuantiles: make([]time.Duration, 100)} + debug.ReadGCStats(gcstats) + + printGC(memStats, gcstats, w) +} + +func printGC(memStats *runtime.MemStats, gcstats *debug.GCStats, w io.Writer) { + + if gcstats.NumGC > 0 { + lastPause := gcstats.Pause[0] + elapsed := time.Now().Sub(startTime) + overhead := float64(gcstats.PauseTotal) / float64(elapsed) * 100 + allocatedRate := float64(memStats.TotalAlloc) / elapsed.Seconds() + + fmt.Fprintf(w, "NumGC:%d Pause:%s Pause(Avg):%s Overhead:%3.2f%% Alloc:%s Sys:%s Alloc(Rate):%s/s Histogram:%s %s %s \n", + gcstats.NumGC, + toS(lastPause), + toS(avg(gcstats.Pause)), + overhead, + toH(memStats.Alloc), + toH(memStats.Sys), + toH(uint64(allocatedRate)), + toS(gcstats.PauseQuantiles[94]), + toS(gcstats.PauseQuantiles[98]), + toS(gcstats.PauseQuantiles[99])) + } else { + // while GC has disabled + elapsed := time.Now().Sub(startTime) + allocatedRate := float64(memStats.TotalAlloc) / elapsed.Seconds() + + fmt.Fprintf(w, "Alloc:%s Sys:%s Alloc(Rate):%s/s\n", + toH(memStats.Alloc), + toH(memStats.Sys), + toH(uint64(allocatedRate))) + } +} + +func avg(items []time.Duration) time.Duration { + var sum time.Duration + for _, item := range items { + sum += item + } + return time.Duration(int64(sum) / int64(len(items))) +} + +// format bytes number friendly +func toH(bytes uint64) string { + switch { + case bytes < 1024: + return fmt.Sprintf("%dB", bytes) + case bytes < 1024*1024: + return fmt.Sprintf("%.2fK", float64(bytes)/1024) + case bytes < 1024*1024*1024: + return fmt.Sprintf("%.2fM", float64(bytes)/1024/1024) + default: + return fmt.Sprintf("%.2fG", float64(bytes)/1024/1024/1024) + } +} + +// short string format +func toS(d time.Duration) string { + + u := uint64(d) + if u < uint64(time.Second) { + switch { + case u == 0: + return "0" + case u < uint64(time.Microsecond): + return fmt.Sprintf("%.2fns", float64(u)) + case u < uint64(time.Millisecond): + return fmt.Sprintf("%.2fus", float64(u)/1000) + default: + return fmt.Sprintf("%.2fms", float64(u)/1000/1000) + } + } else { + switch { + case u < uint64(time.Minute): + return fmt.Sprintf("%.2fs", float64(u)/1000/1000/1000) + case u < uint64(time.Hour): + return fmt.Sprintf("%.2fm", float64(u)/1000/1000/1000/60) + default: + return fmt.Sprintf("%.2fh", float64(u)/1000/1000/1000/60/60) + } + } + +} diff --git a/pkg/toolbox/profile_test.go b/pkg/toolbox/profile_test.go new file mode 100644 index 00000000..07a20c4e --- /dev/null +++ b/pkg/toolbox/profile_test.go @@ -0,0 +1,28 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package toolbox + +import ( + "os" + "testing" +) + +func TestProcessInput(t *testing.T) { + ProcessInput("lookup goroutine", os.Stdout) + ProcessInput("lookup heap", os.Stdout) + ProcessInput("lookup threadcreate", os.Stdout) + ProcessInput("lookup block", os.Stdout) + ProcessInput("gc summary", os.Stdout) +} diff --git a/pkg/toolbox/statistics.go b/pkg/toolbox/statistics.go new file mode 100644 index 00000000..fd73dfb3 --- /dev/null +++ b/pkg/toolbox/statistics.go @@ -0,0 +1,149 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package toolbox + +import ( + "fmt" + "sync" + "time" +) + +// Statistics struct +type Statistics struct { + RequestURL string + RequestController string + RequestNum int64 + MinTime time.Duration + MaxTime time.Duration + TotalTime time.Duration +} + +// URLMap contains several statistics struct to log different data +type URLMap struct { + lock sync.RWMutex + LengthLimit int //limit the urlmap's length if it's equal to 0 there's no limit + urlmap map[string]map[string]*Statistics +} + +// AddStatistics add statistics task. +// it needs request method, request url, request controller and statistics time duration +func (m *URLMap) AddStatistics(requestMethod, requestURL, requestController string, requesttime time.Duration) { + m.lock.Lock() + defer m.lock.Unlock() + if method, ok := m.urlmap[requestURL]; ok { + if s, ok := method[requestMethod]; ok { + s.RequestNum++ + if s.MaxTime < requesttime { + s.MaxTime = requesttime + } + if s.MinTime > requesttime { + s.MinTime = requesttime + } + s.TotalTime += requesttime + } else { + nb := &Statistics{ + RequestURL: requestURL, + RequestController: requestController, + RequestNum: 1, + MinTime: requesttime, + MaxTime: requesttime, + TotalTime: requesttime, + } + m.urlmap[requestURL][requestMethod] = nb + } + + } else { + if m.LengthLimit > 0 && m.LengthLimit <= len(m.urlmap) { + return + } + methodmap := make(map[string]*Statistics) + nb := &Statistics{ + RequestURL: requestURL, + RequestController: requestController, + RequestNum: 1, + MinTime: requesttime, + MaxTime: requesttime, + TotalTime: requesttime, + } + methodmap[requestMethod] = nb + m.urlmap[requestURL] = methodmap + } +} + +// GetMap put url statistics result in io.Writer +func (m *URLMap) GetMap() map[string]interface{} { + m.lock.RLock() + defer m.lock.RUnlock() + + var fields = []string{"requestUrl", "method", "times", "used", "max used", "min used", "avg used"} + + var resultLists [][]string + content := make(map[string]interface{}) + content["Fields"] = fields + + for k, v := range m.urlmap { + for kk, vv := range v { + result := []string{ + fmt.Sprintf("% -50s", k), + fmt.Sprintf("% -10s", kk), + fmt.Sprintf("% -16d", vv.RequestNum), + fmt.Sprintf("%d", vv.TotalTime), + fmt.Sprintf("% -16s", toS(vv.TotalTime)), + fmt.Sprintf("%d", vv.MaxTime), + fmt.Sprintf("% -16s", toS(vv.MaxTime)), + fmt.Sprintf("%d", vv.MinTime), + fmt.Sprintf("% -16s", toS(vv.MinTime)), + fmt.Sprintf("%d", time.Duration(int64(vv.TotalTime)/vv.RequestNum)), + fmt.Sprintf("% -16s", toS(time.Duration(int64(vv.TotalTime)/vv.RequestNum))), + } + resultLists = append(resultLists, result) + } + } + content["Data"] = resultLists + return content +} + +// GetMapData return all mapdata +func (m *URLMap) GetMapData() []map[string]interface{} { + m.lock.RLock() + defer m.lock.RUnlock() + + var resultLists []map[string]interface{} + + for k, v := range m.urlmap { + for kk, vv := range v { + result := map[string]interface{}{ + "request_url": k, + "method": kk, + "times": vv.RequestNum, + "total_time": toS(vv.TotalTime), + "max_time": toS(vv.MaxTime), + "min_time": toS(vv.MinTime), + "avg_time": toS(time.Duration(int64(vv.TotalTime) / vv.RequestNum)), + } + resultLists = append(resultLists, result) + } + } + return resultLists +} + +// StatisticsMap hosld global statistics data map +var StatisticsMap *URLMap + +func init() { + StatisticsMap = &URLMap{ + urlmap: make(map[string]map[string]*Statistics), + } +} diff --git a/pkg/toolbox/statistics_test.go b/pkg/toolbox/statistics_test.go new file mode 100644 index 00000000..ac29476c --- /dev/null +++ b/pkg/toolbox/statistics_test.go @@ -0,0 +1,40 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package toolbox + +import ( + "encoding/json" + "testing" + "time" +) + +func TestStatics(t *testing.T) { + StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(2000)) + StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(120000)) + StatisticsMap.AddStatistics("GET", "/api/user", "&admin.user", time.Duration(13000)) + StatisticsMap.AddStatistics("POST", "/api/admin", "&admin.user", time.Duration(14000)) + StatisticsMap.AddStatistics("POST", "/api/user/astaxie", "&admin.user", time.Duration(12000)) + StatisticsMap.AddStatistics("POST", "/api/user/xiemengjun", "&admin.user", time.Duration(13000)) + StatisticsMap.AddStatistics("DELETE", "/api/user", "&admin.user", time.Duration(1400)) + t.Log(StatisticsMap.GetMap()) + + data := StatisticsMap.GetMapData() + b, err := json.Marshal(data) + if err != nil { + t.Errorf(err.Error()) + } + + t.Log(string(b)) +} diff --git a/pkg/toolbox/task.go b/pkg/toolbox/task.go new file mode 100644 index 00000000..c902fdfc --- /dev/null +++ b/pkg/toolbox/task.go @@ -0,0 +1,640 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package toolbox + +import ( + "log" + "math" + "sort" + "strconv" + "strings" + "sync" + "time" +) + +// bounds provides a range of acceptable values (plus a map of name to value). +type bounds struct { + min, max uint + names map[string]uint +} + +// The bounds for each field. +var ( + AdminTaskList map[string]Tasker + taskLock sync.RWMutex + stop chan bool + changed chan bool + isstart bool + seconds = bounds{0, 59, nil} + minutes = bounds{0, 59, nil} + hours = bounds{0, 23, nil} + days = bounds{1, 31, nil} + months = bounds{1, 12, map[string]uint{ + "jan": 1, + "feb": 2, + "mar": 3, + "apr": 4, + "may": 5, + "jun": 6, + "jul": 7, + "aug": 8, + "sep": 9, + "oct": 10, + "nov": 11, + "dec": 12, + }} + weeks = bounds{0, 6, map[string]uint{ + "sun": 0, + "mon": 1, + "tue": 2, + "wed": 3, + "thu": 4, + "fri": 5, + "sat": 6, + }} +) + +const ( + // Set the top bit if a star was included in the expression. + starBit = 1 << 63 +) + +// Schedule time taks schedule +type Schedule struct { + Second uint64 + Minute uint64 + Hour uint64 + Day uint64 + Month uint64 + Week uint64 +} + +// TaskFunc task func type +type TaskFunc func() error + +// Tasker task interface +type Tasker interface { + GetSpec() string + GetStatus() string + Run() error + SetNext(time.Time) + GetNext() time.Time + SetPrev(time.Time) + GetPrev() time.Time +} + +// task error +type taskerr struct { + t time.Time + errinfo string +} + +// Task task struct +// It's not a thread-safe structure. +// Only nearest errors will be saved in ErrList +type Task struct { + Taskname string + Spec *Schedule + SpecStr string + DoFunc TaskFunc + Prev time.Time + Next time.Time + Errlist []*taskerr // like errtime:errinfo + ErrLimit int // max length for the errlist, 0 stand for no limit + errCnt int // records the error count during the execution +} + +// NewTask add new task with name, time and func +func NewTask(tname string, spec string, f TaskFunc) *Task { + + task := &Task{ + Taskname: tname, + DoFunc: f, + // Make configurable + ErrLimit: 100, + SpecStr: spec, + // we only store the pointer, so it won't use too many space + Errlist: make([]*taskerr, 100, 100), + } + task.SetCron(spec) + return task +} + +// GetSpec get spec string +func (t *Task) GetSpec() string { + return t.SpecStr +} + +// GetStatus get current task status +func (t *Task) GetStatus() string { + var str string + for _, v := range t.Errlist { + str += v.t.String() + ":" + v.errinfo + "
`+
+ ``, c.FieldIDName, value, c.URLPrefix, value, c.URLPrefix, value))
+}
+
+// CreateCaptcha create a new captcha id
+func (c *Captcha) CreateCaptcha() (string, error) {
+ // generate captcha id
+ id := string(utils.RandomCreateBytes(15))
+
+ // get the captcha chars
+ chars := c.genRandChars()
+
+ // save to store
+ if err := c.store.Put(c.key(id), chars, c.Expiration); err != nil {
+ return "", err
+ }
+
+ return id, nil
+}
+
+// VerifyReq verify from a request
+func (c *Captcha) VerifyReq(req *http.Request) bool {
+ req.ParseForm()
+ return c.Verify(req.Form.Get(c.FieldIDName), req.Form.Get(c.FieldCaptchaName))
+}
+
+// Verify direct verify id and challenge string
+func (c *Captcha) Verify(id string, challenge string) (success bool) {
+ if len(challenge) == 0 || len(id) == 0 {
+ return
+ }
+
+ var chars []byte
+
+ key := c.key(id)
+
+ if v, ok := c.store.Get(key).([]byte); ok {
+ chars = v
+ } else {
+ return
+ }
+
+ defer func() {
+ // finally remove it
+ c.store.Delete(key)
+ }()
+
+ if len(chars) != len(challenge) {
+ return
+ }
+ // verify challenge
+ for i, c := range chars {
+ if c != challenge[i]-48 {
+ return
+ }
+ }
+
+ return true
+}
+
+// NewCaptcha create a new captcha.Captcha
+func NewCaptcha(urlPrefix string, store cache.Cache) *Captcha {
+ cpt := &Captcha{}
+ cpt.store = store
+ cpt.FieldIDName = fieldIDName
+ cpt.FieldCaptchaName = fieldCaptchaName
+ cpt.ChallengeNums = challengeNums
+ cpt.Expiration = expiration
+ cpt.CachePrefix = cachePrefix
+ cpt.StdWidth = stdWidth
+ cpt.StdHeight = stdHeight
+
+ if len(urlPrefix) == 0 {
+ urlPrefix = defaultURLPrefix
+ }
+
+ if urlPrefix[len(urlPrefix)-1] != '/' {
+ urlPrefix += "/"
+ }
+
+ cpt.URLPrefix = urlPrefix
+
+ return cpt
+}
+
+// NewWithFilter create a new captcha.Captcha and auto AddFilter for serve captacha image
+// and add a template func for output html
+func NewWithFilter(urlPrefix string, store cache.Cache) *Captcha {
+ cpt := NewCaptcha(urlPrefix, store)
+
+ // create filter for serve captcha image
+ beego.InsertFilter(cpt.URLPrefix+"*", beego.BeforeRouter, cpt.Handler)
+
+ // add to template func map
+ beego.AddFuncMap("create_captcha", cpt.CreateCaptchaHTML)
+
+ return cpt
+}
diff --git a/pkg/utils/captcha/image.go b/pkg/utils/captcha/image.go
new file mode 100644
index 00000000..c3c9a83a
--- /dev/null
+++ b/pkg/utils/captcha/image.go
@@ -0,0 +1,501 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package captcha
+
+import (
+ "bytes"
+ "image"
+ "image/color"
+ "image/png"
+ "io"
+ "math"
+)
+
+const (
+ fontWidth = 11
+ fontHeight = 18
+ blackChar = 1
+
+ // Standard width and height of a captcha image.
+ stdWidth = 240
+ stdHeight = 80
+ // Maximum absolute skew factor of a single digit.
+ maxSkew = 0.7
+ // Number of background circles.
+ circleCount = 20
+)
+
+var font = [][]byte{
+ { // 0
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ },
+ { // 1
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ },
+ { // 2
+ 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ },
+ { // 3
+ 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ },
+ { // 4
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ },
+ { // 5
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ },
+ { // 6
+ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ },
+ { // 7
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ },
+ { // 8
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ },
+ { // 9
+ 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ },
+}
+
+// Image struct
+type Image struct {
+ *image.Paletted
+ numWidth int
+ numHeight int
+ dotSize int
+}
+
+var prng = &siprng{}
+
+// randIntn returns a pseudorandom non-negative int in range [0, n).
+func randIntn(n int) int {
+ return prng.Intn(n)
+}
+
+// randInt returns a pseudorandom int in range [from, to].
+func randInt(from, to int) int {
+ return prng.Intn(to+1-from) + from
+}
+
+// randFloat returns a pseudorandom float64 in range [from, to].
+func randFloat(from, to float64) float64 {
+ return (to-from)*prng.Float64() + from
+}
+
+func randomPalette() color.Palette {
+ p := make([]color.Color, circleCount+1)
+ // Transparent color.
+ p[0] = color.RGBA{0xFF, 0xFF, 0xFF, 0x00}
+ // Primary color.
+ prim := color.RGBA{
+ uint8(randIntn(129)),
+ uint8(randIntn(129)),
+ uint8(randIntn(129)),
+ 0xFF,
+ }
+ p[1] = prim
+ // Circle colors.
+ for i := 2; i <= circleCount; i++ {
+ p[i] = randomBrightness(prim, 255)
+ }
+ return p
+}
+
+// NewImage returns a new captcha image of the given width and height with the
+// given digits, where each digit must be in range 0-9.
+func NewImage(digits []byte, width, height int) *Image {
+ m := new(Image)
+ m.Paletted = image.NewPaletted(image.Rect(0, 0, width, height), randomPalette())
+ m.calculateSizes(width, height, len(digits))
+ // Randomly position captcha inside the image.
+ maxx := width - (m.numWidth+m.dotSize)*len(digits) - m.dotSize
+ maxy := height - m.numHeight - m.dotSize*2
+ var border int
+ if width > height {
+ border = height / 5
+ } else {
+ border = width / 5
+ }
+ x := randInt(border, maxx-border)
+ y := randInt(border, maxy-border)
+ // Draw digits.
+ for _, n := range digits {
+ m.drawDigit(font[n], x, y)
+ x += m.numWidth + m.dotSize
+ }
+ // Draw strike-through line.
+ m.strikeThrough()
+ // Apply wave distortion.
+ m.distort(randFloat(5, 10), randFloat(100, 200))
+ // Fill image with random circles.
+ m.fillWithCircles(circleCount, m.dotSize)
+ return m
+}
+
+// encodedPNG encodes an image to PNG and returns
+// the result as a byte slice.
+func (m *Image) encodedPNG() []byte {
+ var buf bytes.Buffer
+ if err := png.Encode(&buf, m.Paletted); err != nil {
+ panic(err.Error())
+ }
+ return buf.Bytes()
+}
+
+// WriteTo writes captcha image in PNG format into the given writer.
+func (m *Image) WriteTo(w io.Writer) (int64, error) {
+ n, err := w.Write(m.encodedPNG())
+ return int64(n), err
+}
+
+func (m *Image) calculateSizes(width, height, ncount int) {
+ // Goal: fit all digits inside the image.
+ var border int
+ if width > height {
+ border = height / 4
+ } else {
+ border = width / 4
+ }
+ // Convert everything to floats for calculations.
+ w := float64(width - border*2)
+ h := float64(height - border*2)
+ // fw takes into account 1-dot spacing between digits.
+ fw := float64(fontWidth + 1)
+ fh := float64(fontHeight)
+ nc := float64(ncount)
+ // Calculate the width of a single digit taking into account only the
+ // width of the image.
+ nw := w / nc
+ // Calculate the height of a digit from this width.
+ nh := nw * fh / fw
+ // Digit too high?
+ if nh > h {
+ // Fit digits based on height.
+ nh = h
+ nw = fw / fh * nh
+ }
+ // Calculate dot size.
+ m.dotSize = int(nh / fh)
+ if m.dotSize < 1 {
+ m.dotSize = 1
+ }
+ // Save everything, making the actual width smaller by 1 dot to account
+ // for spacing between digits.
+ m.numWidth = int(nw) - m.dotSize
+ m.numHeight = int(nh)
+}
+
+func (m *Image) drawHorizLine(fromX, toX, y int, colorIdx uint8) {
+ for x := fromX; x <= toX; x++ {
+ m.SetColorIndex(x, y, colorIdx)
+ }
+}
+
+func (m *Image) drawCircle(x, y, radius int, colorIdx uint8) {
+ f := 1 - radius
+ dfx := 1
+ dfy := -2 * radius
+ xo := 0
+ yo := radius
+
+ m.SetColorIndex(x, y+radius, colorIdx)
+ m.SetColorIndex(x, y-radius, colorIdx)
+ m.drawHorizLine(x-radius, x+radius, y, colorIdx)
+
+ for xo < yo {
+ if f >= 0 {
+ yo--
+ dfy += 2
+ f += dfy
+ }
+ xo++
+ dfx += 2
+ f += dfx
+ m.drawHorizLine(x-xo, x+xo, y+yo, colorIdx)
+ m.drawHorizLine(x-xo, x+xo, y-yo, colorIdx)
+ m.drawHorizLine(x-yo, x+yo, y+xo, colorIdx)
+ m.drawHorizLine(x-yo, x+yo, y-xo, colorIdx)
+ }
+}
+
+func (m *Image) fillWithCircles(n, maxradius int) {
+ maxx := m.Bounds().Max.X
+ maxy := m.Bounds().Max.Y
+ for i := 0; i < n; i++ {
+ colorIdx := uint8(randInt(1, circleCount-1))
+ r := randInt(1, maxradius)
+ m.drawCircle(randInt(r, maxx-r), randInt(r, maxy-r), r, colorIdx)
+ }
+}
+
+func (m *Image) strikeThrough() {
+ maxx := m.Bounds().Max.X
+ maxy := m.Bounds().Max.Y
+ y := randInt(maxy/3, maxy-maxy/3)
+ amplitude := randFloat(5, 20)
+ period := randFloat(80, 180)
+ dx := 2.0 * math.Pi / period
+ for x := 0; x < maxx; x++ {
+ xo := amplitude * math.Cos(float64(y)*dx)
+ yo := amplitude * math.Sin(float64(x)*dx)
+ for yn := 0; yn < m.dotSize; yn++ {
+ r := randInt(0, m.dotSize)
+ m.drawCircle(x+int(xo), y+int(yo)+(yn*m.dotSize), r/2, 1)
+ }
+ }
+}
+
+func (m *Image) drawDigit(digit []byte, x, y int) {
+ skf := randFloat(-maxSkew, maxSkew)
+ xs := float64(x)
+ r := m.dotSize / 2
+ y += randInt(-r, r)
+ for yo := 0; yo < fontHeight; yo++ {
+ for xo := 0; xo < fontWidth; xo++ {
+ if digit[yo*fontWidth+xo] != blackChar {
+ continue
+ }
+ m.drawCircle(x+xo*m.dotSize, y+yo*m.dotSize, r, 1)
+ }
+ xs += skf
+ x = int(xs)
+ }
+}
+
+func (m *Image) distort(amplude float64, period float64) {
+ w := m.Bounds().Max.X
+ h := m.Bounds().Max.Y
+
+ oldm := m.Paletted
+ newm := image.NewPaletted(image.Rect(0, 0, w, h), oldm.Palette)
+
+ dx := 2.0 * math.Pi / period
+ for x := 0; x < w; x++ {
+ for y := 0; y < h; y++ {
+ xo := amplude * math.Sin(float64(y)*dx)
+ yo := amplude * math.Cos(float64(x)*dx)
+ newm.SetColorIndex(x, y, oldm.ColorIndexAt(x+int(xo), y+int(yo)))
+ }
+ }
+ m.Paletted = newm
+}
+
+func randomBrightness(c color.RGBA, max uint8) color.RGBA {
+ minc := min3(c.R, c.G, c.B)
+ maxc := max3(c.R, c.G, c.B)
+ if maxc > max {
+ return c
+ }
+ n := randIntn(int(max-maxc)) - int(minc)
+ return color.RGBA{
+ uint8(int(c.R) + n),
+ uint8(int(c.G) + n),
+ uint8(int(c.B) + n),
+ c.A,
+ }
+}
+
+func min3(x, y, z uint8) (m uint8) {
+ m = x
+ if y < m {
+ m = y
+ }
+ if z < m {
+ m = z
+ }
+ return
+}
+
+func max3(x, y, z uint8) (m uint8) {
+ m = x
+ if y > m {
+ m = y
+ }
+ if z > m {
+ m = z
+ }
+ return
+}
diff --git a/pkg/utils/captcha/image_test.go b/pkg/utils/captcha/image_test.go
new file mode 100644
index 00000000..5e35b7f7
--- /dev/null
+++ b/pkg/utils/captcha/image_test.go
@@ -0,0 +1,52 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package captcha
+
+import (
+ "testing"
+
+ "github.com/astaxie/beego/utils"
+)
+
+type byteCounter struct {
+ n int64
+}
+
+func (bc *byteCounter) Write(b []byte) (int, error) {
+ bc.n += int64(len(b))
+ return len(b), nil
+}
+
+func BenchmarkNewImage(b *testing.B) {
+ b.StopTimer()
+ d := utils.RandomCreateBytes(challengeNums, defaultChars...)
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ NewImage(d, stdWidth, stdHeight)
+ }
+}
+
+func BenchmarkImageWriteTo(b *testing.B) {
+ b.StopTimer()
+ d := utils.RandomCreateBytes(challengeNums, defaultChars...)
+ b.StartTimer()
+ counter := &byteCounter{}
+ for i := 0; i < b.N; i++ {
+ img := NewImage(d, stdWidth, stdHeight)
+ img.WriteTo(counter)
+ b.SetBytes(counter.n)
+ counter.n = 0
+ }
+}
diff --git a/pkg/utils/captcha/siprng.go b/pkg/utils/captcha/siprng.go
new file mode 100644
index 00000000..5e256cf9
--- /dev/null
+++ b/pkg/utils/captcha/siprng.go
@@ -0,0 +1,277 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package captcha
+
+import (
+ "crypto/rand"
+ "encoding/binary"
+ "io"
+ "sync"
+)
+
+// siprng is PRNG based on SipHash-2-4.
+type siprng struct {
+ mu sync.Mutex
+ k0, k1, ctr uint64
+}
+
+// siphash implements SipHash-2-4, accepting a uint64 as a message.
+func siphash(k0, k1, m uint64) uint64 {
+ // Initialization.
+ v0 := k0 ^ 0x736f6d6570736575
+ v1 := k1 ^ 0x646f72616e646f6d
+ v2 := k0 ^ 0x6c7967656e657261
+ v3 := k1 ^ 0x7465646279746573
+ t := uint64(8) << 56
+
+ // Compression.
+ v3 ^= m
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= m
+
+ // Compress last block.
+ v3 ^= t
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= t
+
+ // Finalization.
+ v2 ^= 0xff
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ return v0 ^ v1 ^ v2 ^ v3
+}
+
+// rekey sets a new PRNG key, which is read from crypto/rand.
+func (p *siprng) rekey() {
+ var k [16]byte
+ if _, err := io.ReadFull(rand.Reader, k[:]); err != nil {
+ panic(err.Error())
+ }
+ p.k0 = binary.LittleEndian.Uint64(k[0:8])
+ p.k1 = binary.LittleEndian.Uint64(k[8:16])
+ p.ctr = 1
+}
+
+// Uint64 returns a new pseudorandom uint64.
+// It rekeys PRNG on the first call and every 64 MB of generated data.
+func (p *siprng) Uint64() uint64 {
+ p.mu.Lock()
+ if p.ctr == 0 || p.ctr > 8*1024*1024 {
+ p.rekey()
+ }
+ v := siphash(p.k0, p.k1, p.ctr)
+ p.ctr++
+ p.mu.Unlock()
+ return v
+}
+
+func (p *siprng) Int63() int64 {
+ return int64(p.Uint64() & 0x7fffffffffffffff)
+}
+
+func (p *siprng) Uint32() uint32 {
+ return uint32(p.Uint64())
+}
+
+func (p *siprng) Int31() int32 {
+ return int32(p.Uint32() & 0x7fffffff)
+}
+
+func (p *siprng) Intn(n int) int {
+ if n <= 0 {
+ panic("invalid argument to Intn")
+ }
+ if n <= 1<<31-1 {
+ return int(p.Int31n(int32(n)))
+ }
+ return int(p.Int63n(int64(n)))
+}
+
+func (p *siprng) Int63n(n int64) int64 {
+ if n <= 0 {
+ panic("invalid argument to Int63n")
+ }
+ max := int64((1 << 63) - 1 - (1<<63)%uint64(n))
+ v := p.Int63()
+ for v > max {
+ v = p.Int63()
+ }
+ return v % n
+}
+
+func (p *siprng) Int31n(n int32) int32 {
+ if n <= 0 {
+ panic("invalid argument to Int31n")
+ }
+ max := int32((1 << 31) - 1 - (1<<31)%uint32(n))
+ v := p.Int31()
+ for v > max {
+ v = p.Int31()
+ }
+ return v % n
+}
+
+func (p *siprng) Float64() float64 { return float64(p.Int63()) / (1 << 63) }
diff --git a/pkg/utils/captcha/siprng_test.go b/pkg/utils/captcha/siprng_test.go
new file mode 100644
index 00000000..189d3d3c
--- /dev/null
+++ b/pkg/utils/captcha/siprng_test.go
@@ -0,0 +1,33 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package captcha
+
+import "testing"
+
+func TestSiphash(t *testing.T) {
+ good := uint64(0xe849e8bb6ffe2567)
+ cur := siphash(0, 0, 0)
+ if cur != good {
+ t.Fatalf("siphash: expected %x, got %x", good, cur)
+ }
+}
+
+func BenchmarkSiprng(b *testing.B) {
+ b.SetBytes(8)
+ p := &siprng{}
+ for i := 0; i < b.N; i++ {
+ p.Uint64()
+ }
+}
diff --git a/pkg/utils/debug.go b/pkg/utils/debug.go
new file mode 100644
index 00000000..93c27b70
--- /dev/null
+++ b/pkg/utils/debug.go
@@ -0,0 +1,478 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "reflect"
+ "runtime"
+)
+
+var (
+ dunno = []byte("???")
+ centerDot = []byte("·")
+ dot = []byte(".")
+)
+
+type pointerInfo struct {
+ prev *pointerInfo
+ n int
+ addr uintptr
+ pos int
+ used []int
+}
+
+// Display print the data in console
+func Display(data ...interface{}) {
+ display(true, data...)
+}
+
+// GetDisplayString return data print string
+func GetDisplayString(data ...interface{}) string {
+ return display(false, data...)
+}
+
+func display(displayed bool, data ...interface{}) string {
+ var pc, file, line, ok = runtime.Caller(2)
+
+ if !ok {
+ return ""
+ }
+
+ var buf = new(bytes.Buffer)
+
+ fmt.Fprintf(buf, "[Debug] at %s() [%s:%d]\n", function(pc), file, line)
+
+ fmt.Fprintf(buf, "\n[Variables]\n")
+
+ for i := 0; i < len(data); i += 2 {
+ var output = fomateinfo(len(data[i].(string))+3, data[i+1])
+ fmt.Fprintf(buf, "%s = %s", data[i], output)
+ }
+
+ if displayed {
+ log.Print(buf)
+ }
+ return buf.String()
+}
+
+// return data dump and format bytes
+func fomateinfo(headlen int, data ...interface{}) []byte {
+ var buf = new(bytes.Buffer)
+
+ if len(data) > 1 {
+ fmt.Fprint(buf, " ")
+
+ fmt.Fprint(buf, "[")
+
+ fmt.Fprintln(buf)
+ }
+
+ for k, v := range data {
+ var buf2 = new(bytes.Buffer)
+ var pointers *pointerInfo
+ var interfaces = make([]reflect.Value, 0, 10)
+
+ printKeyValue(buf2, reflect.ValueOf(v), &pointers, &interfaces, nil, true, " ", 1)
+
+ if k < len(data)-1 {
+ fmt.Fprint(buf2, ", ")
+ }
+
+ fmt.Fprintln(buf2)
+
+ buf.Write(buf2.Bytes())
+ }
+
+ if len(data) > 1 {
+ fmt.Fprintln(buf)
+
+ fmt.Fprint(buf, " ")
+
+ fmt.Fprint(buf, "]")
+ }
+
+ return buf.Bytes()
+}
+
+// check data is golang basic type
+func isSimpleType(val reflect.Value, kind reflect.Kind, pointers **pointerInfo, interfaces *[]reflect.Value) bool {
+ switch kind {
+ case reflect.Bool:
+ return true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return true
+ case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+ return true
+ case reflect.Float32, reflect.Float64:
+ return true
+ case reflect.Complex64, reflect.Complex128:
+ return true
+ case reflect.String:
+ return true
+ case reflect.Chan:
+ return true
+ case reflect.Invalid:
+ return true
+ case reflect.Interface:
+ for _, in := range *interfaces {
+ if reflect.DeepEqual(in, val) {
+ return true
+ }
+ }
+ return false
+ case reflect.UnsafePointer:
+ if val.IsNil() {
+ return true
+ }
+
+ var elem = val.Elem()
+
+ if isSimpleType(elem, elem.Kind(), pointers, interfaces) {
+ return true
+ }
+
+ var addr = val.Elem().UnsafeAddr()
+
+ for p := *pointers; p != nil; p = p.prev {
+ if addr == p.addr {
+ return true
+ }
+ }
+
+ return false
+ }
+
+ return false
+}
+
+// dump value
+func printKeyValue(buf *bytes.Buffer, val reflect.Value, pointers **pointerInfo, interfaces *[]reflect.Value, structFilter func(string, string) bool, formatOutput bool, indent string, level int) {
+ var t = val.Kind()
+
+ switch t {
+ case reflect.Bool:
+ fmt.Fprint(buf, val.Bool())
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ fmt.Fprint(buf, val.Int())
+ case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+ fmt.Fprint(buf, val.Uint())
+ case reflect.Float32, reflect.Float64:
+ fmt.Fprint(buf, val.Float())
+ case reflect.Complex64, reflect.Complex128:
+ fmt.Fprint(buf, val.Complex())
+ case reflect.UnsafePointer:
+ fmt.Fprintf(buf, "unsafe.Pointer(0x%X)", val.Pointer())
+ case reflect.Ptr:
+ if val.IsNil() {
+ fmt.Fprint(buf, "nil")
+ return
+ }
+
+ var addr = val.Elem().UnsafeAddr()
+
+ for p := *pointers; p != nil; p = p.prev {
+ if addr == p.addr {
+ p.used = append(p.used, buf.Len())
+ fmt.Fprintf(buf, "0x%X", addr)
+ return
+ }
+ }
+
+ *pointers = &pointerInfo{
+ prev: *pointers,
+ addr: addr,
+ pos: buf.Len(),
+ used: make([]int, 0),
+ }
+
+ fmt.Fprint(buf, "&")
+
+ printKeyValue(buf, val.Elem(), pointers, interfaces, structFilter, formatOutput, indent, level)
+ case reflect.String:
+ fmt.Fprint(buf, "\"", val.String(), "\"")
+ case reflect.Interface:
+ var value = val.Elem()
+
+ if !value.IsValid() {
+ fmt.Fprint(buf, "nil")
+ } else {
+ for _, in := range *interfaces {
+ if reflect.DeepEqual(in, val) {
+ fmt.Fprint(buf, "repeat")
+ return
+ }
+ }
+
+ *interfaces = append(*interfaces, val)
+
+ printKeyValue(buf, value, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+ }
+ case reflect.Struct:
+ var t = val.Type()
+
+ fmt.Fprint(buf, t)
+ fmt.Fprint(buf, "{")
+
+ for i := 0; i < val.NumField(); i++ {
+ if formatOutput {
+ fmt.Fprintln(buf)
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ var name = t.Field(i).Name
+
+ if formatOutput {
+ for ind := 0; ind < level; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ }
+
+ fmt.Fprint(buf, name)
+ fmt.Fprint(buf, ": ")
+
+ if structFilter != nil && structFilter(t.String(), name) {
+ fmt.Fprint(buf, "ignore")
+ } else {
+ printKeyValue(buf, val.Field(i), pointers, interfaces, structFilter, formatOutput, indent, level+1)
+ }
+
+ fmt.Fprint(buf, ",")
+ }
+
+ if formatOutput {
+ fmt.Fprintln(buf)
+
+ for ind := 0; ind < level-1; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ fmt.Fprint(buf, "}")
+ case reflect.Array, reflect.Slice:
+ fmt.Fprint(buf, val.Type())
+ fmt.Fprint(buf, "{")
+
+ var allSimple = true
+
+ for i := 0; i < val.Len(); i++ {
+ var elem = val.Index(i)
+
+ var isSimple = isSimpleType(elem, elem.Kind(), pointers, interfaces)
+
+ if !isSimple {
+ allSimple = false
+ }
+
+ if formatOutput && !isSimple {
+ fmt.Fprintln(buf)
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ if formatOutput && !isSimple {
+ for ind := 0; ind < level; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ }
+
+ printKeyValue(buf, elem, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+
+ if i != val.Len()-1 || !allSimple {
+ fmt.Fprint(buf, ",")
+ }
+ }
+
+ if formatOutput && !allSimple {
+ fmt.Fprintln(buf)
+
+ for ind := 0; ind < level-1; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ fmt.Fprint(buf, "}")
+ case reflect.Map:
+ var t = val.Type()
+ var keys = val.MapKeys()
+
+ fmt.Fprint(buf, t)
+ fmt.Fprint(buf, "{")
+
+ var allSimple = true
+
+ for i := 0; i < len(keys); i++ {
+ var elem = val.MapIndex(keys[i])
+
+ var isSimple = isSimpleType(elem, elem.Kind(), pointers, interfaces)
+
+ if !isSimple {
+ allSimple = false
+ }
+
+ if formatOutput && !isSimple {
+ fmt.Fprintln(buf)
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ if formatOutput && !isSimple {
+ for ind := 0; ind <= level; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ }
+
+ printKeyValue(buf, keys[i], pointers, interfaces, structFilter, formatOutput, indent, level+1)
+ fmt.Fprint(buf, ": ")
+ printKeyValue(buf, elem, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+
+ if i != val.Len()-1 || !allSimple {
+ fmt.Fprint(buf, ",")
+ }
+ }
+
+ if formatOutput && !allSimple {
+ fmt.Fprintln(buf)
+
+ for ind := 0; ind < level-1; ind++ {
+ fmt.Fprint(buf, indent)
+ }
+ } else {
+ fmt.Fprint(buf, " ")
+ }
+
+ fmt.Fprint(buf, "}")
+ case reflect.Chan:
+ fmt.Fprint(buf, val.Type())
+ case reflect.Invalid:
+ fmt.Fprint(buf, "invalid")
+ default:
+ fmt.Fprint(buf, "unknow")
+ }
+}
+
+// PrintPointerInfo dump pointer value
+func PrintPointerInfo(buf *bytes.Buffer, headlen int, pointers *pointerInfo) {
+ var anyused = false
+ var pointerNum = 0
+
+ for p := pointers; p != nil; p = p.prev {
+ if len(p.used) > 0 {
+ anyused = true
+ }
+ pointerNum++
+ p.n = pointerNum
+ }
+
+ if anyused {
+ var pointerBufs = make([][]rune, pointerNum+1)
+
+ for i := 0; i < len(pointerBufs); i++ {
+ var pointerBuf = make([]rune, buf.Len()+headlen)
+
+ for j := 0; j < len(pointerBuf); j++ {
+ pointerBuf[j] = ' '
+ }
+
+ pointerBufs[i] = pointerBuf
+ }
+
+ for pn := 0; pn <= pointerNum; pn++ {
+ for p := pointers; p != nil; p = p.prev {
+ if len(p.used) > 0 && p.n >= pn {
+ if pn == p.n {
+ pointerBufs[pn][p.pos+headlen] = '└'
+
+ var maxpos = 0
+
+ for i, pos := range p.used {
+ if i < len(p.used)-1 {
+ pointerBufs[pn][pos+headlen] = '┴'
+ } else {
+ pointerBufs[pn][pos+headlen] = '┘'
+ }
+
+ maxpos = pos
+ }
+
+ for i := 0; i < maxpos-p.pos-1; i++ {
+ if pointerBufs[pn][i+p.pos+headlen+1] == ' ' {
+ pointerBufs[pn][i+p.pos+headlen+1] = '─'
+ }
+ }
+ } else {
+ pointerBufs[pn][p.pos+headlen] = '│'
+
+ for _, pos := range p.used {
+ if pointerBufs[pn][pos+headlen] == ' ' {
+ pointerBufs[pn][pos+headlen] = '│'
+ } else {
+ pointerBufs[pn][pos+headlen] = '┼'
+ }
+ }
+ }
+ }
+ }
+
+ buf.WriteString(string(pointerBufs[pn]) + "\n")
+ }
+ }
+}
+
+// Stack get stack bytes
+func Stack(skip int, indent string) []byte {
+ var buf = new(bytes.Buffer)
+
+ for i := skip; ; i++ {
+ var pc, file, line, ok = runtime.Caller(i)
+
+ if !ok {
+ break
+ }
+
+ buf.WriteString(indent)
+
+ fmt.Fprintf(buf, "at %s() [%s:%d]\n", function(pc), file, line)
+ }
+
+ return buf.Bytes()
+}
+
+// return the name of the function containing the PC if possible,
+func function(pc uintptr) []byte {
+ fn := runtime.FuncForPC(pc)
+ if fn == nil {
+ return dunno
+ }
+ name := []byte(fn.Name())
+ // The name includes the path name to the package, which is unnecessary
+ // since the file name is already included. Plus, it has center dots.
+ // That is, we see
+ // runtime/debug.*T·ptrmethod
+ // and want
+ // *T.ptrmethod
+ if period := bytes.Index(name, dot); period >= 0 {
+ name = name[period+1:]
+ }
+ name = bytes.Replace(name, centerDot, dot, -1)
+ return name
+}
diff --git a/pkg/utils/debug_test.go b/pkg/utils/debug_test.go
new file mode 100644
index 00000000..efb8924e
--- /dev/null
+++ b/pkg/utils/debug_test.go
@@ -0,0 +1,46 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+ "testing"
+)
+
+type mytype struct {
+ next *mytype
+ prev *mytype
+}
+
+func TestPrint(t *testing.T) {
+ Display("v1", 1, "v2", 2, "v3", 3)
+}
+
+func TestPrintPoint(t *testing.T) {
+ var v1 = new(mytype)
+ var v2 = new(mytype)
+
+ v1.prev = nil
+ v1.next = v2
+
+ v2.prev = v1
+ v2.next = nil
+
+ Display("v1", v1, "v2", v2)
+}
+
+func TestPrintString(t *testing.T) {
+ str := GetDisplayString("v1", 1, "v2", 2)
+ println(str)
+}
diff --git a/pkg/utils/file.go b/pkg/utils/file.go
new file mode 100644
index 00000000..6090eb17
--- /dev/null
+++ b/pkg/utils/file.go
@@ -0,0 +1,101 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+ "bufio"
+ "errors"
+ "io"
+ "os"
+ "path/filepath"
+ "regexp"
+)
+
+// SelfPath gets compiled executable file absolute path
+func SelfPath() string {
+ path, _ := filepath.Abs(os.Args[0])
+ return path
+}
+
+// SelfDir gets compiled executable file directory
+func SelfDir() string {
+ return filepath.Dir(SelfPath())
+}
+
+// FileExists reports whether the named file or directory exists.
+func FileExists(name string) bool {
+ if _, err := os.Stat(name); err != nil {
+ if os.IsNotExist(err) {
+ return false
+ }
+ }
+ return true
+}
+
+// SearchFile Search a file in paths.
+// this is often used in search config file in /etc ~/
+func SearchFile(filename string, paths ...string) (fullpath string, err error) {
+ for _, path := range paths {
+ if fullpath = filepath.Join(path, filename); FileExists(fullpath) {
+ return
+ }
+ }
+ err = errors.New(fullpath + " not found in paths")
+ return
+}
+
+// GrepFile like command grep -E
+// for example: GrepFile(`^hello`, "hello.txt")
+// \n is striped while read
+func GrepFile(patten string, filename string) (lines []string, err error) {
+ re, err := regexp.Compile(patten)
+ if err != nil {
+ return
+ }
+
+ fd, err := os.Open(filename)
+ if err != nil {
+ return
+ }
+ lines = make([]string, 0)
+ reader := bufio.NewReader(fd)
+ prefix := ""
+ var isLongLine bool
+ for {
+ byteLine, isPrefix, er := reader.ReadLine()
+ if er != nil && er != io.EOF {
+ return nil, er
+ }
+ if er == io.EOF {
+ break
+ }
+ line := string(byteLine)
+ if isPrefix {
+ prefix += line
+ continue
+ } else {
+ isLongLine = true
+ }
+
+ line = prefix + line
+ if isLongLine {
+ prefix = ""
+ }
+ if re.MatchString(line) {
+ lines = append(lines, line)
+ }
+ }
+ return lines, nil
+}
diff --git a/pkg/utils/file_test.go b/pkg/utils/file_test.go
new file mode 100644
index 00000000..b2644157
--- /dev/null
+++ b/pkg/utils/file_test.go
@@ -0,0 +1,75 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+ "path/filepath"
+ "reflect"
+ "testing"
+)
+
+var noExistedFile = "/tmp/not_existed_file"
+
+func TestSelfPath(t *testing.T) {
+ path := SelfPath()
+ if path == "" {
+ t.Error("path cannot be empty")
+ }
+ t.Logf("SelfPath: %s", path)
+}
+
+func TestSelfDir(t *testing.T) {
+ dir := SelfDir()
+ t.Logf("SelfDir: %s", dir)
+}
+
+func TestFileExists(t *testing.T) {
+ if !FileExists("./file.go") {
+ t.Errorf("./file.go should exists, but it didn't")
+ }
+
+ if FileExists(noExistedFile) {
+ t.Errorf("Weird, how could this file exists: %s", noExistedFile)
+ }
+}
+
+func TestSearchFile(t *testing.T) {
+ path, err := SearchFile(filepath.Base(SelfPath()), SelfDir())
+ if err != nil {
+ t.Error(err)
+ }
+ t.Log(path)
+
+ _, err = SearchFile(noExistedFile, ".")
+ if err == nil {
+ t.Errorf("err shouldnt be nil, got path: %s", SelfDir())
+ }
+}
+
+func TestGrepFile(t *testing.T) {
+ _, err := GrepFile("", noExistedFile)
+ if err == nil {
+ t.Error("expect file-not-existed error, but got nothing")
+ }
+
+ path := filepath.Join(".", "testdata", "grepe.test")
+ lines, err := GrepFile(`^\s*[^#]+`, path)
+ if err != nil {
+ t.Error(err)
+ }
+ if !reflect.DeepEqual(lines, []string{"hello", "world"}) {
+ t.Errorf("expect [hello world], but receive %v", lines)
+ }
+}
diff --git a/pkg/utils/mail.go b/pkg/utils/mail.go
new file mode 100644
index 00000000..80a366ca
--- /dev/null
+++ b/pkg/utils/mail.go
@@ -0,0 +1,424 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "mime"
+ "mime/multipart"
+ "net/mail"
+ "net/smtp"
+ "net/textproto"
+ "os"
+ "path"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+const (
+ maxLineLength = 76
+
+ upperhex = "0123456789ABCDEF"
+)
+
+// Email is the type used for email messages
+type Email struct {
+ Auth smtp.Auth
+ Identity string `json:"identity"`
+ Username string `json:"username"`
+ Password string `json:"password"`
+ Host string `json:"host"`
+ Port int `json:"port"`
+ From string `json:"from"`
+ To []string
+ Bcc []string
+ Cc []string
+ Subject string
+ Text string // Plaintext message (optional)
+ HTML string // Html message (optional)
+ Headers textproto.MIMEHeader
+ Attachments []*Attachment
+ ReadReceipt []string
+}
+
+// Attachment is a struct representing an email attachment.
+// Based on the mime/multipart.FileHeader struct, Attachment contains the name, MIMEHeader, and content of the attachment in question
+type Attachment struct {
+ Filename string
+ Header textproto.MIMEHeader
+ Content []byte
+}
+
+// NewEMail create new Email struct with config json.
+// config json is followed from Email struct fields.
+func NewEMail(config string) *Email {
+ e := new(Email)
+ e.Headers = textproto.MIMEHeader{}
+ err := json.Unmarshal([]byte(config), e)
+ if err != nil {
+ return nil
+ }
+ return e
+}
+
+// Bytes Make all send information to byte
+func (e *Email) Bytes() ([]byte, error) {
+ buff := &bytes.Buffer{}
+ w := multipart.NewWriter(buff)
+ // Set the appropriate headers (overwriting any conflicts)
+ // Leave out Bcc (only included in envelope headers)
+ e.Headers.Set("To", strings.Join(e.To, ","))
+ if e.Cc != nil {
+ e.Headers.Set("Cc", strings.Join(e.Cc, ","))
+ }
+ e.Headers.Set("From", e.From)
+ e.Headers.Set("Subject", e.Subject)
+ if len(e.ReadReceipt) != 0 {
+ e.Headers.Set("Disposition-Notification-To", strings.Join(e.ReadReceipt, ","))
+ }
+ e.Headers.Set("MIME-Version", "1.0")
+
+ // Write the envelope headers (including any custom headers)
+ if err := headerToBytes(buff, e.Headers); err != nil {
+ return nil, fmt.Errorf("Failed to render message headers: %s", err)
+ }
+
+ e.Headers.Set("Content-Type", fmt.Sprintf("multipart/mixed;\r\n boundary=%s\r\n", w.Boundary()))
+ fmt.Fprintf(buff, "%s:", "Content-Type")
+ fmt.Fprintf(buff, " %s\r\n", fmt.Sprintf("multipart/mixed;\r\n boundary=%s\r\n", w.Boundary()))
+
+ // Start the multipart/mixed part
+ fmt.Fprintf(buff, "--%s\r\n", w.Boundary())
+ header := textproto.MIMEHeader{}
+ // Check to see if there is a Text or HTML field
+ if e.Text != "" || e.HTML != "" {
+ subWriter := multipart.NewWriter(buff)
+ // Create the multipart alternative part
+ header.Set("Content-Type", fmt.Sprintf("multipart/alternative;\r\n boundary=%s\r\n", subWriter.Boundary()))
+ // Write the header
+ if err := headerToBytes(buff, header); err != nil {
+ return nil, fmt.Errorf("Failed to render multipart message headers: %s", err)
+ }
+ // Create the body sections
+ if e.Text != "" {
+ header.Set("Content-Type", fmt.Sprintf("text/plain; charset=UTF-8"))
+ header.Set("Content-Transfer-Encoding", "quoted-printable")
+ if _, err := subWriter.CreatePart(header); err != nil {
+ return nil, err
+ }
+ // Write the text
+ if err := quotePrintEncode(buff, e.Text); err != nil {
+ return nil, err
+ }
+ }
+ if e.HTML != "" {
+ header.Set("Content-Type", fmt.Sprintf("text/html; charset=UTF-8"))
+ header.Set("Content-Transfer-Encoding", "quoted-printable")
+ if _, err := subWriter.CreatePart(header); err != nil {
+ return nil, err
+ }
+ // Write the text
+ if err := quotePrintEncode(buff, e.HTML); err != nil {
+ return nil, err
+ }
+ }
+ if err := subWriter.Close(); err != nil {
+ return nil, err
+ }
+ }
+ // Create attachment part, if necessary
+ for _, a := range e.Attachments {
+ ap, err := w.CreatePart(a.Header)
+ if err != nil {
+ return nil, err
+ }
+ // Write the base64Wrapped content to the part
+ base64Wrap(ap, a.Content)
+ }
+ if err := w.Close(); err != nil {
+ return nil, err
+ }
+ return buff.Bytes(), nil
+}
+
+// AttachFile Add attach file to the send mail
+func (e *Email) AttachFile(args ...string) (a *Attachment, err error) {
+ if len(args) < 1 || len(args) > 2 { // change && to ||
+ err = errors.New("Must specify a file name and number of parameters can not exceed at least two")
+ return
+ }
+ filename := args[0]
+ id := ""
+ if len(args) > 1 {
+ id = args[1]
+ }
+ f, err := os.Open(filename)
+ if err != nil {
+ return
+ }
+ defer f.Close()
+ ct := mime.TypeByExtension(filepath.Ext(filename))
+ basename := path.Base(filename)
+ return e.Attach(f, basename, ct, id)
+}
+
+// Attach is used to attach content from an io.Reader to the email.
+// Parameters include an io.Reader, the desired filename for the attachment, and the Content-Type.
+func (e *Email) Attach(r io.Reader, filename string, args ...string) (a *Attachment, err error) {
+ if len(args) < 1 || len(args) > 2 { // change && to ||
+ err = errors.New("Must specify the file type and number of parameters can not exceed at least two")
+ return
+ }
+ c := args[0] //Content-Type
+ id := ""
+ if len(args) > 1 {
+ id = args[1] //Content-ID
+ }
+ var buffer bytes.Buffer
+ if _, err = io.Copy(&buffer, r); err != nil {
+ return
+ }
+ at := &Attachment{
+ Filename: filename,
+ Header: textproto.MIMEHeader{},
+ Content: buffer.Bytes(),
+ }
+ // Get the Content-Type to be used in the MIMEHeader
+ if c != "" {
+ at.Header.Set("Content-Type", c)
+ } else {
+ // If the Content-Type is blank, set the Content-Type to "application/octet-stream"
+ at.Header.Set("Content-Type", "application/octet-stream")
+ }
+ if id != "" {
+ at.Header.Set("Content-Disposition", fmt.Sprintf("inline;\r\n filename=\"%s\"", filename))
+ at.Header.Set("Content-ID", fmt.Sprintf("<%s>", id))
+ } else {
+ at.Header.Set("Content-Disposition", fmt.Sprintf("attachment;\r\n filename=\"%s\"", filename))
+ }
+ at.Header.Set("Content-Transfer-Encoding", "base64")
+ e.Attachments = append(e.Attachments, at)
+ return at, nil
+}
+
+// Send will send out the mail
+func (e *Email) Send() error {
+ if e.Auth == nil {
+ e.Auth = smtp.PlainAuth(e.Identity, e.Username, e.Password, e.Host)
+ }
+ // Merge the To, Cc, and Bcc fields
+ to := make([]string, 0, len(e.To)+len(e.Cc)+len(e.Bcc))
+ to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
+ // Check to make sure there is at least one recipient and one "From" address
+ if len(to) == 0 {
+ return errors.New("Must specify at least one To address")
+ }
+
+ // Use the username if no From is provided
+ if len(e.From) == 0 {
+ e.From = e.Username
+ }
+
+ from, err := mail.ParseAddress(e.From)
+ if err != nil {
+ return err
+ }
+
+ // use mail's RFC 2047 to encode any string
+ e.Subject = qEncode("utf-8", e.Subject)
+
+ raw, err := e.Bytes()
+ if err != nil {
+ return err
+ }
+ return smtp.SendMail(e.Host+":"+strconv.Itoa(e.Port), e.Auth, from.Address, to, raw)
+}
+
+// quotePrintEncode writes the quoted-printable text to the IO Writer (according to RFC 2045)
+func quotePrintEncode(w io.Writer, s string) error {
+ var buf [3]byte
+ mc := 0
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ // We're assuming Unix style text formats as input (LF line break), and
+ // quoted-printble uses CRLF line breaks. (Literal CRs will become
+ // "=0D", but probably shouldn't be there to begin with!)
+ if c == '\n' {
+ io.WriteString(w, "\r\n")
+ mc = 0
+ continue
+ }
+
+ var nextOut []byte
+ if isPrintable(c) {
+ nextOut = append(buf[:0], c)
+ } else {
+ nextOut = buf[:]
+ qpEscape(nextOut, c)
+ }
+
+ // Add a soft line break if the next (encoded) byte would push this line
+ // to or past the limit.
+ if mc+len(nextOut) >= maxLineLength {
+ if _, err := io.WriteString(w, "=\r\n"); err != nil {
+ return err
+ }
+ mc = 0
+ }
+
+ if _, err := w.Write(nextOut); err != nil {
+ return err
+ }
+ mc += len(nextOut)
+ }
+ // No trailing end-of-line?? Soft line break, then. TODO: is this sane?
+ if mc > 0 {
+ io.WriteString(w, "=\r\n")
+ }
+ return nil
+}
+
+// isPrintable returns true if the rune given is "printable" according to RFC 2045, false otherwise
+func isPrintable(c byte) bool {
+ return (c >= '!' && c <= '<') || (c >= '>' && c <= '~') || (c == ' ' || c == '\n' || c == '\t')
+}
+
+// qpEscape is a helper function for quotePrintEncode which escapes a
+// non-printable byte. Expects len(dest) == 3.
+func qpEscape(dest []byte, c byte) {
+ const nums = "0123456789ABCDEF"
+ dest[0] = '='
+ dest[1] = nums[(c&0xf0)>>4]
+ dest[2] = nums[(c & 0xf)]
+}
+
+// headerToBytes enumerates the key and values in the header, and writes the results to the IO Writer
+func headerToBytes(w io.Writer, t textproto.MIMEHeader) error {
+ for k, v := range t {
+ // Write the header key
+ _, err := fmt.Fprintf(w, "%s:", k)
+ if err != nil {
+ return err
+ }
+ // Write each value in the header
+ for _, c := range v {
+ _, err := fmt.Fprintf(w, " %s\r\n", c)
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// base64Wrap encodes the attachment content, and wraps it according to RFC 2045 standards (every 76 chars)
+// The output is then written to the specified io.Writer
+func base64Wrap(w io.Writer, b []byte) {
+ // 57 raw bytes per 76-byte base64 line.
+ const maxRaw = 57
+ // Buffer for each line, including trailing CRLF.
+ var buffer [maxLineLength + len("\r\n")]byte
+ copy(buffer[maxLineLength:], "\r\n")
+ // Process raw chunks until there's no longer enough to fill a line.
+ for len(b) >= maxRaw {
+ base64.StdEncoding.Encode(buffer[:], b[:maxRaw])
+ w.Write(buffer[:])
+ b = b[maxRaw:]
+ }
+ // Handle the last chunk of bytes.
+ if len(b) > 0 {
+ out := buffer[:base64.StdEncoding.EncodedLen(len(b))]
+ base64.StdEncoding.Encode(out, b)
+ out = append(out, "\r\n"...)
+ w.Write(out)
+ }
+}
+
+// Encode returns the encoded-word form of s. If s is ASCII without special
+// characters, it is returned unchanged. The provided charset is the IANA
+// charset name of s. It is case insensitive.
+// RFC 2047 encoded-word
+func qEncode(charset, s string) string {
+ if !needsEncoding(s) {
+ return s
+ }
+ return encodeWord(charset, s)
+}
+
+func needsEncoding(s string) bool {
+ for _, b := range s {
+ if (b < ' ' || b > '~') && b != '\t' {
+ return true
+ }
+ }
+ return false
+}
+
+// encodeWord encodes a string into an encoded-word.
+func encodeWord(charset, s string) string {
+ buf := getBuffer()
+
+ buf.WriteString("=?")
+ buf.WriteString(charset)
+ buf.WriteByte('?')
+ buf.WriteByte('q')
+ buf.WriteByte('?')
+
+ enc := make([]byte, 3)
+ for i := 0; i < len(s); i++ {
+ b := s[i]
+ switch {
+ case b == ' ':
+ buf.WriteByte('_')
+ case b <= '~' && b >= '!' && b != '=' && b != '?' && b != '_':
+ buf.WriteByte(b)
+ default:
+ enc[0] = '='
+ enc[1] = upperhex[b>>4]
+ enc[2] = upperhex[b&0x0f]
+ buf.Write(enc)
+ }
+ }
+ buf.WriteString("?=")
+
+ es := buf.String()
+ putBuffer(buf)
+ return es
+}
+
+var bufPool = sync.Pool{
+ New: func() interface{} {
+ return new(bytes.Buffer)
+ },
+}
+
+func getBuffer() *bytes.Buffer {
+ return bufPool.Get().(*bytes.Buffer)
+}
+
+func putBuffer(buf *bytes.Buffer) {
+ if buf.Len() > 1024 {
+ return
+ }
+ buf.Reset()
+ bufPool.Put(buf)
+}
diff --git a/pkg/utils/mail_test.go b/pkg/utils/mail_test.go
new file mode 100644
index 00000000..c38356a2
--- /dev/null
+++ b/pkg/utils/mail_test.go
@@ -0,0 +1,41 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import "testing"
+
+func TestMail(t *testing.T) {
+ config := `{"username":"astaxie@gmail.com","password":"astaxie","host":"smtp.gmail.com","port":587}`
+ mail := NewEMail(config)
+ if mail.Username != "astaxie@gmail.com" {
+ t.Fatal("email parse get username error")
+ }
+ if mail.Password != "astaxie" {
+ t.Fatal("email parse get password error")
+ }
+ if mail.Host != "smtp.gmail.com" {
+ t.Fatal("email parse get host error")
+ }
+ if mail.Port != 587 {
+ t.Fatal("email parse get port error")
+ }
+ mail.To = []string{"xiemengjun@gmail.com"}
+ mail.From = "astaxie@gmail.com"
+ mail.Subject = "hi, just from beego!"
+ mail.Text = "Text Body is, of course, supported!"
+ mail.HTML = "