_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q18300 | CreateView | train | func (jenkins *Jenkins) CreateView(listView ListView) error {
xmlListView, _ := xml.Marshal(listView)
reader := bytes.NewReader(xmlListView)
params := url.Values{"name": []string{listView.Name}}
return jenkins.postXml("/createView", params, reader, nil)
} | go | {
"resource": ""
} |
q18301 | Build | train | func (jenkins *Jenkins) Build(job Job, params url.Values) error {
if hasParams(job) {
return jenkins.post(fmt.Sprintf("/job/%s/buildWithParameters", job.Name), params, nil)
} else {
return jenkins.post(fmt.Sprintf("/job/%s/build", job.Name), params, nil)
}
} | go | {
"resource": ""
} |
q18302 | GetBuildConsoleOutput | train | func (jenkins *Jenkins) GetBuildConsoleOutput(build Build) ([]byte, error) {
requestUrl := fmt.Sprintf("%s/consoleText", build.Url)
req, err := http.NewRequest("GET", requestUrl, nil)
if err != nil {
return nil, err
}
res, err := jenkins.sendRequest(req)
if err != nil {
return nil, err
}
defer res.Body.Cl... | go | {
"resource": ""
} |
q18303 | GetQueue | train | func (jenkins *Jenkins) GetQueue() (queue Queue, err error) {
err = jenkins.get(fmt.Sprintf("/queue"), nil, &queue)
return
} | go | {
"resource": ""
} |
q18304 | SetBuildDescription | train | func (jenkins *Jenkins) SetBuildDescription(build Build, description string) error {
requestUrl := fmt.Sprintf("%ssubmitDescription?description=%s", build.Url, url.QueryEscape(description))
req, err := http.NewRequest("GET", requestUrl, nil)
if err != nil {
return err
}
res, err := jenkins.sendRequest(req)
if ... | go | {
"resource": ""
} |
q18305 | GetComputerObject | train | func (jenkins *Jenkins) GetComputerObject() (co ComputerObject, err error) {
err = jenkins.get(fmt.Sprintf("/computer"), nil, &co)
return
} | go | {
"resource": ""
} |
q18306 | GetComputers | train | func (jenkins *Jenkins) GetComputers() ([]Computer, error) {
var payload = struct {
Computers []Computer `json:"computer"`
}{}
err := jenkins.get("/computer", nil, &payload)
return payload.Computers, err
} | go | {
"resource": ""
} |
q18307 | GetComputer | train | func (jenkins *Jenkins) GetComputer(name string) (computer Computer, err error) {
err = jenkins.get(fmt.Sprintf("/computer/%s", name), nil, &computer)
return
} | go | {
"resource": ""
} |
q18308 | hasParams | train | func hasParams(job Job) bool {
for _, action := range job.Actions {
if len(action.ParameterDefinitions) > 0 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q18309 | UnmarshalXML | train | func (iscm *Scm) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
for _, v := range start.Attr {
if v.Name.Local == "class" {
iscm.Class = v.Value
} else if v.Name.Local == "plugin" {
iscm.Plugin = v.Value
}
}
switch iscm.Class {
case "hudson.scm.SubversionSCM":
iscm.ScmContent = &ScmSvn{}... | go | {
"resource": ""
} |
q18310 | Get | train | func (r *Response) Get(key string) string {
return r.handlerHeader.Get(key)
} | go | {
"resource": ""
} |
q18311 | ErrByStatus | train | func ErrByStatus(status int) *Error {
switch status {
case 400:
return ErrBadRequest
case 401:
return ErrUnauthorized
case 402:
return ErrPaymentRequired
case 403:
return ErrForbidden
case 404:
return ErrNotFound
case 405:
return ErrMethodNotAllowed
case 406:
return ErrNotAcceptable
case 407:
r... | go | {
"resource": ""
} |
q18312 | Use | train | func (r *Router) Use(handle Middleware) *Router {
r.mds = append(r.mds, handle)
r.middleware = Compose(r.mds...)
return r
} | go | {
"resource": ""
} |
q18313 | Get | train | func (r *Router) Get(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodGet, pattern, handlers...)
} | go | {
"resource": ""
} |
q18314 | Head | train | func (r *Router) Head(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodHead, pattern, handlers...)
} | go | {
"resource": ""
} |
q18315 | Post | train | func (r *Router) Post(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodPost, pattern, handlers...)
} | go | {
"resource": ""
} |
q18316 | Put | train | func (r *Router) Put(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodPut, pattern, handlers...)
} | go | {
"resource": ""
} |
q18317 | Patch | train | func (r *Router) Patch(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodPatch, pattern, handlers...)
} | go | {
"resource": ""
} |
q18318 | Delete | train | func (r *Router) Delete(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodDelete, pattern, handlers...)
} | go | {
"resource": ""
} |
q18319 | Options | train | func (r *Router) Options(pattern string, handlers ...Middleware) *Router {
return r.Handle(http.MethodOptions, pattern, handlers...)
} | go | {
"resource": ""
} |
q18320 | Otherwise | train | func (r *Router) Otherwise(handlers ...Middleware) *Router {
if len(handlers) == 0 {
panic(Err.WithMsg("invalid middleware"))
}
r.otherwise = Compose(handlers...)
return r
} | go | {
"resource": ""
} |
q18321 | Serve | train | func (r *Router) Serve(ctx *Context) error {
path := ctx.Path
method := ctx.Method
var handler Middleware
if !strings.HasPrefix(path, r.root) && path != r.rt {
return nil
}
if path == r.rt {
path = "/"
} else if l := len(r.rt); l > 0 {
path = path[l:]
}
matched := r.trie.Match(path)
if matched.Node ... | go | {
"resource": ""
} |
q18322 | NewWithIco | train | func NewWithIco(file []byte, times ...time.Time) gear.Middleware {
modTime := time.Now()
reader := bytes.NewReader(file)
if len(times) > 0 {
modTime = times[0]
}
return func(ctx *gear.Context) (err error) {
if ctx.Path != "/favicon.ico" {
return
}
if ctx.Method != http.MethodGet && ctx.Method != http.M... | go | {
"resource": ""
} |
q18323 | colorString | train | func colorString(code int, str string) string {
return fmt.Sprintf("\x1b[%d;1m%s\x1b[39;22m", code, str)
} | go | {
"resource": ""
} |
q18324 | NewContext | train | func NewContext(app *App, w http.ResponseWriter, r *http.Request) *Context {
ctx := Context{
app: app,
Req: r,
Res: &Response{w: w, rw: w, handlerHeader: w.Header()},
Host: r.Host,
Method: r.Method,
Path: r.URL.Path,
Cookies: cookie.New(w, r, app.keys...),
kv: make(map[interface{}]interface{... | go | {
"resource": ""
} |
q18325 | Cancel | train | func (ctx *Context) Cancel() {
ctx.Res.ended.setTrue() // end the middleware process
ctx.Res.afterHooks = nil
ctx.cancelCtx()
} | go | {
"resource": ""
} |
q18326 | WithCancel | train | func (ctx *Context) WithCancel() (context.Context, context.CancelFunc) {
return context.WithCancel(ctx._ctx)
} | go | {
"resource": ""
} |
q18327 | WithDeadline | train | func (ctx *Context) WithDeadline(deadline time.Time) (context.Context, context.CancelFunc) {
return context.WithDeadline(ctx._ctx, deadline)
} | go | {
"resource": ""
} |
q18328 | WithValue | train | func (ctx *Context) WithValue(key, val interface{}) context.Context {
return context.WithValue(ctx._ctx, key, val)
} | go | {
"resource": ""
} |
q18329 | Timing | train | func (ctx *Context) Timing(dt time.Duration, fn func(context.Context)) (err error) {
ct, cancel := ctx.WithTimeout(dt)
defer cancel()
ch := make(chan error, 1) // not block tryRunTiming
go tryRunTiming(ct, fn, ch)
select {
case <-ct.Done():
err = ct.Err()
case err = <-ch:
}
return
} | go | {
"resource": ""
} |
q18330 | MustAny | train | func (ctx *Context) MustAny(any interface{}) interface{} {
val, err := ctx.Any(any)
if err != nil {
panic(err)
}
return val
} | go | {
"resource": ""
} |
q18331 | IP | train | func (ctx *Context) IP(trustedProxy ...bool) net.IP {
trusted := ctx.Setting(SetTrustedProxy).(bool)
if len(trustedProxy) > 0 {
trusted = trustedProxy[0]
}
if trusted {
ip := ctx.Req.Header.Get(HeaderXForwardedFor)
if ip == "" {
ip = ctx.Req.Header.Get(HeaderXRealIP)
} else if i := strings.IndexByte(ip,... | go | {
"resource": ""
} |
q18332 | AcceptType | train | func (ctx *Context) AcceptType(preferred ...string) string {
return negotiator.New(ctx.Req.Header).Type(preferred...)
} | go | {
"resource": ""
} |
q18333 | AcceptLanguage | train | func (ctx *Context) AcceptLanguage(preferred ...string) string {
return negotiator.New(ctx.Req.Header).Language(preferred...)
} | go | {
"resource": ""
} |
q18334 | AcceptEncoding | train | func (ctx *Context) AcceptEncoding(preferred ...string) string {
return negotiator.New(ctx.Req.Header).Encoding(preferred...)
} | go | {
"resource": ""
} |
q18335 | AcceptCharset | train | func (ctx *Context) AcceptCharset(preferred ...string) string {
return negotiator.New(ctx.Req.Header).Charset(preferred...)
} | go | {
"resource": ""
} |
q18336 | Query | train | func (ctx *Context) Query(name string) string {
if ctx.query == nil {
ctx.query = ctx.Req.URL.Query()
}
return ctx.query.Get(name)
} | go | {
"resource": ""
} |
q18337 | Set | train | func (ctx *Context) Set(key, value string) {
ctx.SetHeader(key, value)
} | go | {
"resource": ""
} |
q18338 | GetHeader | train | func (ctx *Context) GetHeader(key string) string {
switch key {
case "Referer", "referer", "Referrer", "referrer":
if val := ctx.Req.Header.Get("Referer"); val != "" {
return val
}
return ctx.Req.Header.Get("Referrer")
default:
return ctx.Req.Header.Get(key)
}
} | go | {
"resource": ""
} |
q18339 | HTML | train | func (ctx *Context) HTML(code int, str string) error {
ctx.Type(MIMETextHTMLCharsetUTF8)
return ctx.End(code, []byte(str))
} | go | {
"resource": ""
} |
q18340 | JSONBlob | train | func (ctx *Context) JSONBlob(code int, buf []byte) error {
ctx.Type(MIMEApplicationJSONCharsetUTF8)
return ctx.End(code, buf)
} | go | {
"resource": ""
} |
q18341 | JSONPBlob | train | func (ctx *Context) JSONPBlob(code int, callback string, buf []byte) error {
ctx.Type(MIMEApplicationJavaScriptCharsetUTF8)
ctx.SetHeader(HeaderXContentTypeOptions, "nosniff")
// the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse"
// @see http://miki.it/blog/2014/7/8/abusing-jsonp-with-rosett... | go | {
"resource": ""
} |
q18342 | XMLBlob | train | func (ctx *Context) XMLBlob(code int, buf []byte) error {
ctx.Type(MIMEApplicationXMLCharsetUTF8)
return ctx.End(code, buf)
} | go | {
"resource": ""
} |
q18343 | Stream | train | func (ctx *Context) Stream(code int, contentType string, r io.Reader) (err error) {
if ctx.Res.ended.swapTrue() {
ctx.Status(code)
ctx.Type(contentType)
_, err = io.Copy(ctx.Res, r)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.Stream")
}
return
} | go | {
"resource": ""
} |
q18344 | Attachment | train | func (ctx *Context) Attachment(name string, modtime time.Time, content io.ReadSeeker, inline ...bool) (err error) {
if ctx.Res.ended.swapTrue() {
dispositionType := "attachment"
if len(inline) > 0 && inline[0] {
dispositionType = "inline"
}
ctx.SetHeader(HeaderContentDisposition, ContentDisposition(name, di... | go | {
"resource": ""
} |
q18345 | Redirect | train | func (ctx *Context) Redirect(url string) (err error) {
if ctx.Res.ended.swapTrue() {
if !isRedirectStatus(ctx.Res.status) {
ctx.Res.status = http.StatusFound
}
http.Redirect(ctx.Res, ctx.Req, url, ctx.Res.status)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.Redirect")
}
return
... | go | {
"resource": ""
} |
q18346 | OkHTML | train | func (ctx *Context) OkHTML(str string) error {
return ctx.HTML(http.StatusOK, str)
} | go | {
"resource": ""
} |
q18347 | OkXML | train | func (ctx *Context) OkXML(val interface{}) error {
return ctx.XML(http.StatusOK, val)
} | go | {
"resource": ""
} |
q18348 | OkSend | train | func (ctx *Context) OkSend(val interface{}) error {
return ctx.Send(http.StatusOK, val)
} | go | {
"resource": ""
} |
q18349 | OkRender | train | func (ctx *Context) OkRender(name string, val interface{}) error {
return ctx.Render(http.StatusOK, name, val)
} | go | {
"resource": ""
} |
q18350 | OkStream | train | func (ctx *Context) OkStream(contentType string, r io.Reader) error {
return ctx.Stream(http.StatusOK, contentType, r)
} | go | {
"resource": ""
} |
q18351 | ErrorStatus | train | func (ctx *Context) ErrorStatus(status int) error {
if status >= 400 && IsStatusCode(status) {
return ctx.Error(ErrByStatus(status))
}
return ErrInternalServerError.WithMsg("invalid error status")
} | go | {
"resource": ""
} |
q18352 | End | train | func (ctx *Context) End(code int, buf ...[]byte) (err error) {
if ctx.Res.ended.swapTrue() {
var body []byte
if len(buf) > 0 {
body = buf[0]
}
err = ctx.Res.respond(code, body)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.End")
}
return
} | go | {
"resource": ""
} |
q18353 | After | train | func (ctx *Context) After(hook func()) {
if ctx.Res.ended.isTrue() { // should not add afterHooks if ctx.Res.ended
panic(Err.WithMsg(`can't add "after hook" after middleware process ended`))
}
ctx.Res.afterHooks = append(ctx.Res.afterHooks, hook)
} | go | {
"resource": ""
} |
q18354 | New | train | func New(srv http.Handler) gear.Middleware {
return func(ctx *gear.Context) error {
// "application/grpc", "application/grpc+proto"
if strings.HasPrefix(ctx.GetHeader(gear.HeaderContentType), "application/grpc") {
srv.ServeHTTP(ctx.Res, ctx.Req)
ctx.End(204) // Must end with 204 to handle rpc error
}
ret... | go | {
"resource": ""
} |
q18355 | HidePoweredBy | train | func HidePoweredBy() gear.Middleware {
return func(ctx *gear.Context) error {
ctx.After(func() {
ctx.Res.Header().Del(gear.HeaderXPoweredBy)
})
return nil
}
} | go | {
"resource": ""
} |
q18356 | Parse | train | func (d DefaultURLParser) Parse(val map[string][]string, body interface{}, tag string) error {
return ValuesToStruct(val, body, tag)
} | go | {
"resource": ""
} |
q18357 | Parse | train | func (d DefaultBodyParser) Parse(buf []byte, body interface{}, mediaType, charset string) error {
if len(buf) == 0 {
return ErrBadRequest.WithMsg("request entity empty")
}
switch true {
case mediaType == MIMEApplicationJSON, isLikeMediaType(mediaType, "json"):
err := json.Unmarshal(buf, body)
if err == nil {
... | go | {
"resource": ""
} |
q18358 | New | train | func New() *App {
app := new(App)
app.Server = new(http.Server)
app.mds = make(middlewares, 0)
app.settings = make(map[interface{}]interface{})
env := os.Getenv("APP_ENV")
if env == "" {
env = "development"
}
app.Set(SetEnv, env)
app.Set(SetServerName, "Gear/"+Version)
app.Set(SetTrustedProxy, false)
app.... | go | {
"resource": ""
} |
q18359 | Use | train | func (app *App) Use(handle Middleware) *App {
app.mds = append(app.mds, handle)
return app
} | go | {
"resource": ""
} |
q18360 | UseHandler | train | func (app *App) UseHandler(h Handler) *App {
app.mds = append(app.mds, h.Serve)
return app
} | go | {
"resource": ""
} |
q18361 | Listen | train | func (app *App) Listen(addr string) error {
app.Server.Addr = addr
app.Server.ErrorLog = app.logger
app.Server.Handler = app
return app.Server.ListenAndServe()
} | go | {
"resource": ""
} |
q18362 | ListenTLS | train | func (app *App) ListenTLS(addr, certFile, keyFile string) error {
app.Server.Addr = addr
app.Server.ErrorLog = app.logger
app.Server.Handler = app
return app.Server.ListenAndServeTLS(certFile, keyFile)
} | go | {
"resource": ""
} |
q18363 | Error | train | func (app *App) Error(err interface{}) {
if err := ErrorWithStack(err, 4); err != nil {
str, e := err.Format()
f := app.logger.Flags() == 0
switch {
case f && e == nil:
app.logger.Printf("[%s] ERR %s\n", time.Now().UTC().Format("2006-01-02T15:04:05.999Z"), str)
case f && e != nil:
app.logger.Printf("[%... | go | {
"resource": ""
} |
q18364 | Close | train | func (app *App) Close(ctx ...context.Context) error {
if len(ctx) > 0 {
return app.Server.Shutdown(ctx[0])
}
return app.Server.Close()
} | go | {
"resource": ""
} |
q18365 | Compose | train | func Compose(mds ...Middleware) Middleware {
switch len(mds) {
case 0:
return noOp
case 1:
return mds[0]
default:
return middlewares(mds).run
}
} | go | {
"resource": ""
} |
q18366 | WrapHandler | train | func WrapHandler(handler http.Handler) Middleware {
return func(ctx *Context) error {
handler.ServeHTTP(ctx.Res, ctx.Req)
return nil
}
} | go | {
"resource": ""
} |
q18367 | WrapHandlerFunc | train | func WrapHandlerFunc(fn http.HandlerFunc) Middleware {
return func(ctx *Context) error {
fn(ctx.Res, ctx.Req)
return nil
}
} | go | {
"resource": ""
} |
q18368 | Error | train | func (err *Error) Error() string {
return fmt.Sprintf("%s: %s", err.Err, err.Msg)
} | go | {
"resource": ""
} |
q18369 | Format | train | func (err Error) Format() (string, error) {
errlog := errorForLog{err.Code, err.Err, err.Msg, err.Data, err.Stack}
res, e := json.Marshal(errlog)
if e == nil {
return string(res), nil
}
return "", e
} | go | {
"resource": ""
} |
q18370 | ParseError | train | func ParseError(e error, code ...int) HTTPError {
if IsNil(e) {
return nil
}
switch v := e.(type) {
case HTTPError:
return v
case *textproto.Error:
err := Err.WithCode(v.Code)
err.Msg = v.Msg
return err
default:
err := ErrInternalServerError.WithMsg(e.Error())
if len(code) > 0 && code[0] > 0 {
e... | go | {
"resource": ""
} |
q18371 | ErrorWithStack | train | func ErrorWithStack(val interface{}, skip ...int) *Error {
if IsNil(val) {
return nil
}
var err *Error
switch v := val.(type) {
case *Error:
err = v.WithMsg() // must clone, should not change the origin *Error instance
case error:
err = ErrInternalServerError.From(v)
case string:
err = ErrInternalServer... | go | {
"resource": ""
} |
q18372 | Add | train | func (s *LoggerFilterWriter) Add(err string) {
if s.out == nil {
panic(Err.WithMsg("output io.Writer should be set with SetOutput method"))
}
s.phrases = append(s.phrases, []byte(err))
} | go | {
"resource": ""
} |
q18373 | Decompress | train | func Decompress(encoding string, r io.Reader) (io.ReadCloser, error) {
switch encoding {
case "gzip":
return gzip.NewReader(r)
case "deflate", "zlib":
// compatible for RFC 1950 zlib, RFC 1951 deflate, http://www.open-open.com/lib/view/open1460866410410.html
return zlib.NewReader(r)
default:
return nil, Err... | go | {
"resource": ""
} |
q18374 | New | train | func New(options ...Options) gear.Middleware {
opts := Options{}
if len(options) > 0 {
opts = options[0]
}
if opts.AllowOrigins == nil {
opts.AllowOrigins = defaultAllowOrigins
}
if opts.AllowMethods == nil {
opts.AllowMethods = defaultAllowMethods
}
if opts.AllowOriginsValidator == nil {
opts.AllowOrig... | go | {
"resource": ""
} |
q18375 | Format | train | func (l Log) Format() (string, error) {
res, err := json.Marshal(l)
if err == nil {
return string(res), nil
}
return "", err
} | go | {
"resource": ""
} |
q18376 | ParseLevel | train | func ParseLevel(lvl string) (Level, error) {
switch strings.ToUpper(lvl) {
case "EMERGENCY", "EMERG":
return EmergLevel, nil
case "ALERT":
return AlertLevel, nil
case "CRITICAL", "CRIT", "CRITI":
return CritiLevel, nil
case "ERROR", "ERR":
return ErrLevel, nil
case "WARNING", "WARN":
return WarningLevel... | go | {
"resource": ""
} |
q18377 | Default | train | func Default(devMode ...bool) *Logger {
if len(devMode) > 0 && devMode[0] {
std.SetLogConsume(developmentConsume)
}
return std
} | go | {
"resource": ""
} |
q18378 | Emerg | train | func (l *Logger) Emerg(v interface{}) {
l.Output(time.Now(), EmergLevel, formatError(v))
} | go | {
"resource": ""
} |
q18379 | Alert | train | func (l *Logger) Alert(v interface{}) {
if l.checkLogLevel(AlertLevel) {
l.Output(time.Now(), AlertLevel, formatError(v))
}
} | go | {
"resource": ""
} |
q18380 | Crit | train | func (l *Logger) Crit(v interface{}) {
if l.checkLogLevel(CritiLevel) {
l.Output(time.Now(), CritiLevel, formatError(v))
}
} | go | {
"resource": ""
} |
q18381 | Err | train | func (l *Logger) Err(v interface{}) {
if l.checkLogLevel(ErrLevel) {
l.Output(time.Now(), ErrLevel, formatError(v))
}
} | go | {
"resource": ""
} |
q18382 | Warning | train | func (l *Logger) Warning(v interface{}) {
if l.checkLogLevel(WarningLevel) {
l.Output(time.Now(), WarningLevel, format(v))
}
} | go | {
"resource": ""
} |
q18383 | Notice | train | func (l *Logger) Notice(v interface{}) {
if l.checkLogLevel(NoticeLevel) {
l.Output(time.Now(), NoticeLevel, format(v))
}
} | go | {
"resource": ""
} |
q18384 | Info | train | func (l *Logger) Info(v interface{}) {
if l.checkLogLevel(InfoLevel) {
l.Output(time.Now(), InfoLevel, format(v))
}
} | go | {
"resource": ""
} |
q18385 | Debug | train | func (l *Logger) Debug(v interface{}) {
if l.checkLogLevel(DebugLevel) {
l.Output(time.Now(), DebugLevel, format(v))
}
} | go | {
"resource": ""
} |
q18386 | Debugf | train | func (l *Logger) Debugf(format string, args ...interface{}) {
if l.checkLogLevel(DebugLevel) {
l.Output(time.Now(), DebugLevel, fmt.Sprintf(format, args...))
}
} | go | {
"resource": ""
} |
q18387 | Panic | train | func (l *Logger) Panic(v interface{}) {
s := format(v)
l.Emerg(s)
panic(s)
} | go | {
"resource": ""
} |
q18388 | Print | train | func (l *Logger) Print(args ...interface{}) {
l.mu.Lock()
defer l.mu.Unlock()
fmt.Fprint(l.Out, args...)
} | go | {
"resource": ""
} |
q18389 | Printf | train | func (l *Logger) Printf(format string, args ...interface{}) {
l.mu.Lock()
defer l.mu.Unlock()
fmt.Fprintf(l.Out, format, args...)
} | go | {
"resource": ""
} |
q18390 | Println | train | func (l *Logger) Println(args ...interface{}) {
l.mu.Lock()
defer l.mu.Unlock()
fmt.Fprintln(l.Out, args...)
} | go | {
"resource": ""
} |
q18391 | Output | train | func (l *Logger) Output(t time.Time, level Level, s string) (err error) {
l.mu.Lock()
defer l.mu.Unlock()
if l := len(s); l > 0 && s[l-1] == '\n' {
s = s[0 : l-1]
}
_, err = fmt.Fprintf(l.Out, l.lf, t.UTC().Format(l.tf), level.String(), crlfEscaper.Replace(s))
if err == nil {
l.Out.Write([]byte{'\n'})
}
re... | go | {
"resource": ""
} |
q18392 | GetLevel | train | func (l *Logger) GetLevel() Level {
l.mu.Lock()
defer l.mu.Unlock()
return l.l
} | go | {
"resource": ""
} |
q18393 | SetLevel | train | func (l *Logger) SetLevel(level Level) *Logger {
l.mu.Lock()
defer l.mu.Unlock()
if level > DebugLevel {
panic(gear.Err.WithMsg("invalid logger level"))
}
l.l = level
return l
} | go | {
"resource": ""
} |
q18394 | SetLogInit | train | func (l *Logger) SetLogInit(fn func(Log, *gear.Context)) *Logger {
l.mu.Lock()
defer l.mu.Unlock()
l.init = fn
return l
} | go | {
"resource": ""
} |
q18395 | New | train | func (l *Logger) New(ctx *gear.Context) (interface{}, error) {
log := Log{}
l.init(log, ctx)
return log, nil
} | go | {
"resource": ""
} |
q18396 | FromCtx | train | func (l *Logger) FromCtx(ctx *gear.Context) Log {
any, _ := ctx.Any(l)
return any.(Log)
} | go | {
"resource": ""
} |
q18397 | GetDatasets | train | func (c *Client) GetDatasets(ctx context.Context) ([]*Dataset, error) {
datasets := make([]*Dataset, 0)
req, err := c.NewRequest("GET", datasetsPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &datasets); err != nil {
return nil, err
}
return datasets, nil
} | go | {
"resource": ""
} |
q18398 | GetDatasetFiles | train | func (c *Client) GetDatasetFiles(ctx context.Context, name string) ([]*DatasetFile, error) {
files := make([]*DatasetFile, 0)
path := fmt.Sprintf(datasetFilesPath, name)
req, err := c.NewRequest("GET", path, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &files); err != nil {
return ni... | go | {
"resource": ""
} |
q18399 | GetAlerts | train | func (c *Client) GetAlerts(ctx context.Context) ([]*Alert, error) {
alerts := make([]*Alert, 0, 0)
req, err := c.NewRequest("GET", alertsInfoListPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &alerts); err != nil {
return nil, err
}
return alerts, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.