func initRoutes() bool {
if inited {
return false
}
inited = true
Handle("/goroutine", "Get goroutine info",
pprofLookupHandler("goroutine"))
Handle("/heap", "Get heap info",
pprofLookupHandler("heap"))
Handle("/thread", "Get thread create info",
pprofLookupHandler("threadcreate"))
Handle("/block", "Get block info",
pprofLookupHandler("block"))
Handle("/cpu", "Get CPU info, default seconds is 30, use ?seconds= to reset",
func(req zerver.Request, resp zerver.Response) {
var t int
if secs := req.Param("seconds"); secs != "" {
var err error
if t, err = strconv.Atoi(secs); err != nil {
resp.ReportBadRequest()
resp.WriteString(secs + " is not a integer number\n")
return
}
}
if t <= 0 {
t = 30
}
pprof.StartCPUProfile(resp)
time.Sleep(time.Duration(t) * time.Second)
pprof.StopCPUProfile()
})
Handle("/memory", "Get memory info",
func(req zerver.Request, resp zerver.Response) {
runtime.GC()
pprof.WriteHeapProfile(resp)
})
Handle("/routes", "Get all routes",
func(req zerver.Request, resp zerver.Response) {
req.Server().PrintRouteTree(resp)
})
Handle("/options", "Get all pprof options",
func(req zerver.Request, resp zerver.Response) {
if from := req.Param("from"); from != "" {
resp.Write(unsafe2.Bytes("There is no this pprof option: " + from + "\n"))
}
for i := range options {
resp.Write(unsafe2.Bytes(options[i]))
}
})
return inited
}
func base(out io.Writer, tmpl gotmpl.Tmpl, data interface{}) error {
var err error
_, err = out.Write(unsafe2.Bytes(``))
if err != nil {
return err
}
_, err = out.Write(unsafe2.Bytes(`
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
`))
if err != nil {
return err
}
err = tmpl.Encode(out, fmt.Sprint(data))
if err != nil {
return err
}
_, err = out.Write(unsafe2.Bytes(`
</body>
</html>
`))
if err != nil {
return err
}
err = tmpl.Encode(out, "aa")
if err != nil {
return err
}
_, err = out.Write(unsafe2.Bytes(`
`))
if err != nil {
return err
}
err = tmpl.Render(out, "tests/extend", "aa")
if err != nil {
return err
}
_, err = out.Write(unsafe2.Bytes(``))
if err != nil {
return err
}
return err
}
// RenderTo render string to writer
func (r *Renderer) RenderTo(w io.Writer, str string) (int, error) {
if str == "" || !r.enable {
return w.Write(unsafe2.Bytes(str))
}
if err := r.Begin(w); err == nil {
c, err := w.Write(unsafe2.Bytes(str))
r.End(w)
return c, err
} else {
return 0, err
}
}
func (x *Xsrf) VerifyFor(req zerver.Request) bool {
m := req.ReqMethod()
if !x.FilterGet && (m == zerver.METHOD_GET || m == zerver.METHOD_HEAD || m == zerver.METHOD_OPTIONS) {
return true
}
token := req.GetHeader(_HEADER_XSRFTOKEN)
if token == "" {
token = req.GetHeader(_HEADER_CSRFTOKEN)
if token == "" {
token = req.Vars().QueryVar(_XSRF_PARAM_NAME)
if token == "" {
return false
}
}
}
data := x.verify(unsafe2.Bytes(token))
if data != nil {
x.Pool.Put(data)
t, ip := x.TokenInfo.Unmarshal(data)
return t != -1 &&
t+x.Timeout >= time2.Now().Unix() &&
ip == http2.IpOfAddr(req.RemoteAddr())
}
return false
}
func (x *Xsrf) VerifyFor(req zerver.Request) bool {
m := req.Method()
if !x.FilterGet && (m == "GET" || m == "HEAD" || m == "OPTIONS") {
return true
}
token := req.Header(_HEADER_XSRFTOKEN)
if token == "" {
token = req.Header(_HEADER_CSRFTOKEN)
if token == "" {
token = req.Param(_XSRF_PARAM_NAME)
if token == "" {
return false
}
}
}
data := x.verify(unsafe2.Bytes(token))
if data != nil {
x.Pool.Put(data)
t, ip, agent := x.TokenInfo.Unmarshal(data)
return t != -1 &&
t+x.Timeout >= time2.Now().Unix() &&
ip == req.RemoteIP() &&
agent == req.UserAgent()
}
return false
}
// WriteString write string to writer
func (m WriteMode) WriteString(fname, str string) (c int, err error) {
err = file.OpenOrCreate(fname, bool(m), func(fd *os.File) error {
c, err = fd.Write(unsafe2.Bytes(str))
return err
})
return
}
func TestCipher(t *testing.T) {
tt := testing2.Wrap(t)
c := NewCipher([]byte("12345"), time.Second*100, md5.New, encoding.Base64URL)
for _, s := range []string{"a", "b", "c", "d", "e", "fdddddddddddddddddddddd"} {
tok := c.Encode(unsafe2.Bytes(s))
tt.Log(string(tok), len(tok))
ds, err := c.Decode(tok)
tt.DeepEq(unsafe2.Bytes(s), ds).Nil(err)
}
for _, s := range []string{"a", "b", "c", "d", ""} {
tok := c.Encode(unsafe2.Bytes(s))
ds, err := c.Decode(tok)
tt.DeepEq(unsafe2.Bytes(s), ds).Nil(err)
}
}
// WriteL write a string list to writer, return total bytes writed
func WriteLString(w io.Writer, strs ...string) (n int, err error) {
var c int
for i := range strs {
if c, err = w.Write(unsafe2.Bytes(strs[i])); err == nil {
n += c
} else {
break
}
}
return
}
func (r *Renderer) RenderStringTo(w io.Writer, str ...string) (int, error) {
err := r.Begin(w)
var (
n int
c int
)
for i := 0; err == nil && i < len(str); i++ {
c, err = w.Write(unsafe2.Bytes(str[i]))
n += c
}
r.End(w)
return n, err
}
func (w Writer) Write(bs []byte) (int, error) {
i, err := w.Writer.Write(unsafe2.Bytes(w.Prefix))
if err != nil {
return 0, err
}
n, err := w.RenderTo(w.Writer, unsafe2.String(bs))
if err != nil {
return 0, err
}
return n + i, nil
}
func WriteIfString(w io.Writer, v interface{}) (bool, error) {
switch s := v.(type) {
case string:
_, err := w.Write(unsafe2.Bytes(s))
return true, err
case []byte:
_, err := w.Write(s)
return true, err
}
return false, nil
}
func WriteGZIP(w io.Writer, v interface{}) (err error) {
gw := gzip.NewWriter(w)
switch v := v.(type) {
case string:
_, err = gw.Write(unsafe2.Bytes(v))
case []byte:
_, err = gw.Write(v)
default:
err = errors.Err("Only support string and []byte")
}
gw.Close()
return
}
func BenchmarkConn(b *testing.B) {
buf := make([]byte, 1024)
for i := 0; i < b.N; i++ {
fmt.Println(b.N, conn == nil)
conn.Write(unsafe2.Bytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"))
fmt.Println(b.N, conn == nil)
n, err := conn.Read(buf)
if err != nil {
return
}
buf = buf[:n]
buf = buf[:1024]
}
}
func ReadCommenttedJSON(fname, comment string, v interface{}) error {
var trim = func(line, delim []byte) []byte {
if len(delim) > 0 && bytes.HasPrefix(bytes.TrimSpace(line), delim) {
return nil
}
return line
}
return file.Read(fname, func(fd *os.File) error {
bs, err := ioutil.ReadAll(fd)
if err != nil {
return err
}
bs = bytes2.MultipleLineOperate(bs, unsafe2.Bytes(comment), trim)
return json.Unmarshal(bs, v)
})
}
// printRouteTree print route tree with given parent path
func (rt *router) printRouteTree(w io.Writer, parentPath string) {
if parentPath != "" {
parentPath = parentPath + _PRINT_SEP
}
s := []byte(rt.str)
for i := range s {
if s[i] == _WILDCARD {
s[i] = _MATCH_WILDCARD
} else if s[i] == _REMAINSALL {
s[i] = _MATCH_REMAINSALL
}
}
cur := parentPath + string(s)
if _, e := w.Write(unsafe2.Bytes(cur + "\n")); e == nil {
rt.accessAllChilds(func(n *router) bool {
n.printRouteTree(w, cur)
return true
})
}
}
func (c *Cipher) encrypt(now int64, str string) string {
hash := hmac.New(c.Hash, unsafe2.Bytes(c.SecretKey))
if now == 0 {
now = time.Now().Add(c.TTL).UnixNano()
}
hash.Write(unsafe2.Bytes(str))
hash.Write(unsafe2.Bytes(c.segSep()))
nows := strconv.FormatInt(now, 10)
hash.Write(unsafe2.Bytes(nows))
hash.Write(unsafe2.Bytes(c.segSep()))
hash.Write(unsafe2.Bytes(c.SecretKey))
sig := hash.Sum(nil)
sigStr := hex.EncodeToString(sig[:hash.Size()/2])
return str + c.segSep() + nows + c.segSep() + sigStr[:len(sigStr)/2]
}
func (r *Renderer) Fprint(w io.Writer, args ...interface{}) (int, error) {
s := fmt.Sprint(args...)
return r.RenderTo(w, unsafe2.Bytes(s))
}
func WriteString(w io.Writer, s string) (int, error) {
return w.Write(unsafe2.Bytes(s))
}
func process(path string, wg *sync.WaitGroup) {
sectionState := PARSE_INIT
dataState := PARSE_INIT
var a *API
var sec *section
var category string = "global"
dataStart := 0
err := file.Filter(path, func(linum int, line []byte) error {
line = bytes.Replace(line, tab, tabreplace, -1)
originLine := string(line)
if !bytes.HasPrefix(line, unsafe2.Bytes(comment)) {
sectionState = PARSE_INIT
return nil
}
line = bytes.TrimSpace(line[len(comment):])
line = bytes.Replace(line, []byte{'\t'}, []byte(" "), -1)
if len(line) == 0 {
return nil
}
linestr := string(line)
switch tag := matchTag(linestr); tag {
case TAG_CATEGORY:
category = strings.TrimSpace(linestr[tag.Strlen():])
case TAG_API:
a = &API{}
sectionState = PARSE_API
name := strings.TrimSpace(linestr[tag.Strlen():])
names := strings2.SplitAndTrim(name, TAG_AT_CATEGORY)
a.name = names[0]
if len(names) > 1 {
as.AddAPI(names[1], a)
} else {
as.AddAPI(category, a)
}
case TAG_SUBAPI:
a = &API{}
sectionState = PARSE_API
a.name = strings.TrimSpace(linestr[tag.Strlen():])
as.AddSubAPI(a.name, a)
case TAG_APIINCL:
if a != nil {
a.subapis = append(a.subapis, strings2.SplitAndTrim(linestr[tag.Strlen():], ",")...)
}
case TAG_ENDAPI:
sectionState = PARSE_INIT
case TAG_HEADER:
sec = §ion{}
sectionState = PARSE_BODY
dataState = PARSE_HEADER
as.AddSubHeader(strings.TrimSpace(linestr[tag.Strlen():]), sec)
case TAG_HEADERINCL:
if sec != nil {
sec.subheaders = append(sec.subheaders, strings2.SplitAndTrim(linestr[tag.Strlen():], ",")...)
}
case TAG_RESP:
if sectionState != PARSE_INIT {
sectionState = PARSE_BODY
dataState = PARSE_STATUS
sec = §ion{}
a.resps = append(a.resps, sec)
}
case TAG_SUBRESP:
name := strings.TrimSpace(linestr[tag.Strlen():])
sectionState = PARSE_BODY
dataState = PARSE_STATUS
sec = §ion{}
as.AddSubResp(name, sec)
case TAG_RESPINCL:
if a != nil {
a.subresps = append(a.subresps, strings2.SplitAndTrim(linestr[tag.Strlen():], ",")...)
}
case TAG_REQ:
if sectionState != PARSE_INIT {
sectionState = PARSE_BODY
sec = §ion{}
a.req = sec
dataState = PARSE_STATUS
}
default:
if sectionState == PARSE_INIT {
break
} else if sectionState == PARSE_API {
a.desc = append(a.desc, linestr)
break
}
switch dataState {
case PARSE_STATUS:
sec.headerLine = linestr
dataState = PARSE_HEADER
case PARSE_HEADER:
if !strings.HasPrefix(linestr, TAG_DATA.String()) {
sec.headers = append(sec.headers, linestr)
break
}
dataStart = strings.Index(originLine, TAG_DATA.String()) + TAG_DATA.Strlen()
dataState = PARSE_DATA
fallthrough
case PARSE_DATA:
if len(originLine) >= dataStart {
sec.datas = append(sec.datas, originLine[dataStart:])
} else {
reportErrorln("skipped data line: %s:%d:%s", path, linum, originLine)
}
}
}
return nil
})
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
wg.Done()
}
func (c *wsConn) WriteString(s string) (int, error) {
return c.Write(unsafe2.Bytes(s))
}
func (b *Buffer) WriteString(s string) (int, error) {
return b.Write(unsafe2.Bytes(s))
}
func (r *Renderer) End(w io.Writer) error {
_, err := w.Write(unsafe2.Bytes(r.end))
return err
}
// WriteStringln write string to writer and append a newline character
func WriteStringln(w io.Writer, s string) (int, error) {
return Writeln(w, unsafe2.Bytes(s))
}
func (wsc *webSocketConn) WriteString(s string) (int, error) {
return wsc.Write(unsafe2.Bytes(s))
}
func (x *Xsrf) hash() hash.Hash {
return hmac.New(x.HashMethod, unsafe2.Bytes(x.Secret))
}
func (w *ErrorWriter) WriteString(s string) (int, error) {
return w.WriteDo(unsafe2.Bytes(s), nil)
}
func (resp *response) WriteString(s string) (int, error) {
return resp.Write(unsafe2.Bytes(s))
}
func (r *Router) PrintRouteTree(w io.Writer) {
for i := range r.routers {
w.Write(unsafe2.Bytes(r.hosts[i] + "\n"))
r.routers[i].PrintRouteTree(w)
}
}
func ErrWriteString(err *error, w io.Writer, s string) {
if *err == nil {
_, *err = w.Write(unsafe2.Bytes(s))
}
}
func (r *Renderer) Begin(w io.Writer) error {
_, err := w.Write(unsafe2.Bytes(r.settings))
return err
}