func (j *JSONP) Init(zerver.Env) error { if j.CallbackVar == "" { return errors.Err("callback name should not be empty") } j.log = log.Derive("Filter", "JSONP") return nil }
// Init must be called func (h *Handler) Init(env zerver.Env) error { if h.SaveImage == nil { panic("the function to save image should not be nil") } defval.Int64(&h.MaxMemory, 1<<19) // 512K defval.String(&h.FileKey, "image") if h.ErrNoFile == nil { h.ErrNoFile = httperrs.BadRequest.NewS("upload file not exists") } if h.Suffixes == nil { h.AddSuffixes("png", "jpg") } if h.ErrNonImage == nil { h.ErrNonImage = httperrs.BadRequest.NewS("the upload file is not an image") } defval.Int64(&h.MaxSize, 1<<18) // 256K if h.ErrTooLarge == nil { h.ErrTooLarge = httperrs.BadRequest.NewS("the upload file size is too large") } h.log = log.Derive("Component", "ImageHandler") return nil }
func (ri *RequestId) Init(env zerver.Env) error { defval.Nil(&ri.Store, new(MemIDStore)) ri.Store.Init(env) defval.String(&ri.HeaderName, "X-Request-Id") defval.String(&ri.Error, "header value X-Request-Id can't be empty") defval.String(&ri.ErrorOverlap, "request already accepted before, please wait") ri.log = log.Derive("Component", "RequestId") return nil }
func (o *ServerOption) init() { if o.Logger == nil { o.Logger = log.Derive("Framework", "Server") } defval.String(&o.ListenAddr, ":4000") if o.KeepAlivePeriod == 0 { o.KeepAlivePeriod = 3 * time.Minute // same as net/http/server.go:tcpKeepAliveListener } if o.Codec == nil { o.Codec = encoding.JSON } }
func New(clearInterval time.Duration, backend Backend) *Master { m := &Master{ log: log.Derive("TimingMsq", ""), Backend: backend, undeleted: make(set.Strings), } ex, is := backend.(Expirer) if !(is && ex.HasExpiration()) { go m.start(clearInterval) } return m }
func RunRemote(tunnel proxy.Proxy, signal Signal) error { ln, err := net2.RetryListen("tcp", tunnel.Addr(), 5, 1000) if err != nil { return err } r := &Remote{ tunnel: tunnel, signal: signal, listener: ln, log: log.Derive("Remote", tunnel.Addr()), } go r.serve() return nil }
func (m *Queue) Init(env zerver.Env) error { if m.Processor == nil { return errors.Err("message processor shouldn't be nil") } if m.TaskBufsize == 0 { m.TaskBufsize = 256 } if m.BytesPool == nil { m.BytesPool = bytes2.NewFakePool() } m.queue = make(chan zerver.Task, m.TaskBufsize) m.log = log.Derive("TaskHandler", "MessageQueue") go m.start() return nil }
func (x *Xsrf) Init(env zerver.Env) error { if x.Secret == "" { return errors.Err("xsrf secret can't be empty") } defval.Int64(&x.Timeout, _DEF_XSRF_TIMEOUT) defval.Nil(&x.HashMethod, sha256.New) defval.String(&x.Error, "xsrf token is invalid or not found") if x.UsePool { if x.Pool == nil { x.Pool = bytes2.NewSyncPool(0, true) } } else { x.Pool = bytes2.FakePool{} } defval.Nil(&x.TokenInfo, jsonToken{}) x.log = log.Derive("Component", "Xsrf") return nil }
func RunLocal(sock proxy.Proxy, tunnels []proxy.Proxy, signal Signal, directList, tunnelList, suffixList *SiteList) error { ln, err := net2.RetryListen("tcp", sock.Addr(), 5, 1000) if err != nil { return err } local := &Local{ directList: directList, tunnelList: tunnelList, suffixList: suffixList, sock: sock, tunnels: tunnels, listener: ln, signal: signal, log: log.Derive("Local", sock.Addr()), } go local.serve() return nil }
func (r *Recovery) Init(env zerver.Env) error { defval.Int(&r.Bufsize, 1024*4) r.log = log.Derive("Filter", "Recovery") return nil }
func (l *Log) Init(env zerver.Env) error { l.log = log.Derive("Filter", "Log") return nil }