id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c18300 | := url.Values{"name": []string{listView.Name}}
return jenkins.postXml("/createView", params, reader, nil)
} | |
c18301 | job.Name), params, nil)
} else {
return jenkins.post(fmt.Sprintf("/job/%s/build", job.Name), params, nil)
}
} | |
c18302 | res, err := jenkins.sendRequest(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
return ioutil.ReadAll(res.Body)
} | |
c18303 | = jenkins.get(fmt.Sprintf("/queue"), nil, &queue)
return
} | |
c18304 |
if err != nil {
return err
}
res, err := jenkins.sendRequest(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != 200 {
return fmt.Errorf("Unexpected response: expected '200' but received '%d'", res.StatusCode)
}
return nil
} | |
c18305 | err = jenkins.get(fmt.Sprintf("/computer"), nil, &co)
return
} | |
c18306 | := jenkins.get("/computer", nil, &payload)
return payload.Computers, err
} | |
c18307 | err = jenkins.get(fmt.Sprintf("/computer/%s", name), nil, &computer)
return
} | |
c18308 | len(action.ParameterDefinitions) > 0 {
return true
}
}
return false
} | |
c18309 | }
switch iscm.Class {
case "hudson.scm.SubversionSCM":
iscm.ScmContent = &ScmSvn{}
err := d.DecodeElement(&iscm.ScmContent, &start)
if err != nil {
return err
}
case "hudson.plugins.git.GitSCM":
iscm.ScmContent = &ScmGit{}
err := d.DecodeElement(&iscm.ScmContent, &start)
if err != nil {
return e... | |
c18310 | r.handlerHeader.Get(key)
} | |
c18311 |
return ErrUnavailableForLegalReasons
case 499:
return ErrClientClosedRequest
case 500:
return ErrInternalServerError
case 501:
return ErrNotImplemented
case 502:
return ErrBadGateway
case 503:
return ErrServiceUnavailable
case 504:
return ErrGatewayTimeout
case 505:
return ErrHTTPVersionNotSuppo... | |
c18312 |
r.middleware = Compose(r.mds...)
return r
} | |
c18313 | r.Handle(http.MethodGet, pattern, handlers...)
} | |
c18314 | r.Handle(http.MethodHead, pattern, handlers...)
} | |
c18315 | r.Handle(http.MethodPost, pattern, handlers...)
} | |
c18316 | r.Handle(http.MethodPut, pattern, handlers...)
} | |
c18317 | r.Handle(http.MethodPatch, pattern, handlers...)
} | |
c18318 | r.Handle(http.MethodDelete, pattern, handlers...)
} | |
c18319 | r.Handle(http.MethodOptions, pattern, handlers...)
} | |
c18320 | panic(Err.WithMsg("invalid middleware"))
}
r.otherwise = Compose(handlers...)
return r
} | |
c18321 | // OPTIONS support
if method == http.MethodOptions {
ctx.SetHeader(HeaderAllow, matched.Node.GetAllow())
return ctx.End(http.StatusNoContent)
}
if r.otherwise == nil {
// If no route handler is returned, it's a 405 error
ctx.SetHeader(HeaderAllow, matched.Node.GetAllow())
return ErrMethod... | |
c18322 | "text/plain; charset=utf-8")
ctx.SetHeader(gear.HeaderAllow, "GET, HEAD, OPTIONS")
return ctx.End(status)
}
ctx.Type("image/x-icon")
http.ServeContent(ctx.Res, ctx.Req, "favicon.ico", modTime, reader)
return
}
} | |
c18323 | {
return fmt.Sprintf("\x1b[%d;1m%s\x1b[39;22m", code, str)
} | |
c18324 | context.WithValue(ctx.ctx, isContext, isContext)
if app.withContext != nil {
ctx._ctx = app.withContext(r.WithContext(ctx.ctx))
if ctx._ctx.Value(isContext) == nil {
panic(Err.WithMsg("the context is not created from gear.Context"))
}
} else {
ctx._ctx = ctx.ctx
}
return &ctx
} | |
c18325 | process
ctx.Res.afterHooks = nil
ctx.cancelCtx()
} | |
c18326 | context.CancelFunc) {
return context.WithCancel(ctx._ctx)
} | |
c18327 | context.WithDeadline(ctx._ctx, deadline)
} | |
c18328 | context.WithValue(ctx._ctx, key, val)
} | |
c18329 | 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
} | |
c18330 | {
val, err := ctx.Any(any)
if err != nil {
panic(err)
}
return val
} | |
c18331 |
if realIP := net.ParseIP(ip); realIP != nil {
return realIP
}
}
ra := ctx.Req.RemoteAddr
ra, _, _ = net.SplitHostPort(ra)
return net.ParseIP(ra)
} | |
c18332 | negotiator.New(ctx.Req.Header).Type(preferred...)
} | |
c18333 | negotiator.New(ctx.Req.Header).Language(preferred...)
} | |
c18334 | negotiator.New(ctx.Req.Header).Encoding(preferred...)
} | |
c18335 | negotiator.New(ctx.Req.Header).Charset(preferred...)
} | |
c18336 | == nil {
ctx.query = ctx.Req.URL.Query()
}
return ctx.query.Get(name)
} | |
c18337 | string) {
ctx.SetHeader(key, value)
} | |
c18338 |
return ctx.Req.Header.Get("Referrer")
default:
return ctx.Req.Header.Get(key)
}
} | |
c18339 | ctx.Type(MIMETextHTMLCharsetUTF8)
return ctx.End(code, []byte(str))
} | |
c18340 | ctx.Type(MIMEApplicationJSONCharsetUTF8)
return ctx.End(code, buf)
} | |
c18341 | client error noise
b := []byte(fmt.Sprintf(`/**/ typeof %s === "function" && %s(`, callback, callback))
b = append(b, buf...)
return ctx.End(code, append(b, ')', ';'))
} | |
c18342 | ctx.Type(MIMEApplicationXMLCharsetUTF8)
return ctx.End(code, buf)
} | |
c18343 | err = ErrInternalServerError.WithMsg("request ended before ctx.Stream")
}
return
} | |
c18344 |
http.ServeContent(ctx.Res, ctx.Req, name, modtime, content)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.Attachment")
}
return
} | |
c18345 | http.Redirect(ctx.Res, ctx.Req, url, ctx.Res.status)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.Redirect")
}
return
} | |
c18346 | ctx.HTML(http.StatusOK, str)
} | |
c18347 | ctx.XML(http.StatusOK, val)
} | |
c18348 | ctx.Send(http.StatusOK, val)
} | |
c18349 | return ctx.Render(http.StatusOK, name, val)
} | |
c18350 |
return ctx.Stream(http.StatusOK, contentType, r)
} | |
c18351 | {
return ctx.Error(ErrByStatus(status))
}
return ErrInternalServerError.WithMsg("invalid error status")
} | |
c18352 | = ctx.Res.respond(code, body)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.End")
}
return
} | |
c18353 | process ended`))
}
ctx.Res.afterHooks = append(ctx.Res.afterHooks, hook)
} | |
c18354 | srv.ServeHTTP(ctx.Res, ctx.Req)
ctx.End(204) // Must end with 204 to handle rpc error
}
return nil
}
} | |
c18355 | ctx.Res.Header().Del(gear.HeaderXPoweredBy)
})
return nil
}
} | |
c18356 | error {
return ValuesToStruct(val, body, tag)
} | |
c18357 | else if se, ok := err.(*json.SyntaxError); ok {
return fmt.Errorf("Syntax error: offset=%v, error=%v", se.Offset, se.Error())
} else {
return err
}
case mediaType == MIMEApplicationXML, isLikeMediaType(mediaType, "xml"):
return xml.Unmarshal(buf, body)
case mediaType == MIMEApplicationForm:
val, err :=... | |
c18358 |
app.Set(SetURLParser, DefaultURLParser{})
app.Set(SetLogger, log.New(os.Stderr, "", 0))
app.Set(SetParseError, func(err error) HTTPError {
return ParseError(err)
})
app.Set(SetOnError, func(ctx *Context, err HTTPError) {
ctx.Error(err)
})
return app
} | |
c18359 | = append(app.mds, handle)
return app
} | |
c18360 | = append(app.mds, h.Serve)
return app
} | |
c18361 |
app.Server.Handler = app
return app.Server.ListenAndServe()
} | |
c18362 | = addr
app.Server.ErrorLog = app.logger
app.Server.Handler = app
return app.Server.ListenAndServeTLS(certFile, keyFile)
} | |
c18363 | str)
case f && e != nil:
app.logger.Printf("[%s] CRIT %s\n", time.Now().UTC().Format("2006-01-02T15:04:05.999Z"), err.String())
case !f && e == nil:
app.logger.Printf("ERR %s\n", str)
default:
app.logger.Printf("CRIT %s\n", err.String())
}
}
} | |
c18364 | len(ctx) > 0 {
return app.Server.Shutdown(ctx[0])
}
return app.Server.Close()
} | |
c18365 | 1:
return mds[0]
default:
return middlewares(mds).run
}
} | |
c18366 |
handler.ServeHTTP(ctx.Res, ctx.Req)
return nil
}
} | |
c18367 | fn(ctx.Res, ctx.Req)
return nil
}
} | |
c18368 | fmt.Sprintf("%s: %s", err.Err, err.Msg)
} | |
c18369 | err.Msg, err.Data, err.Stack}
res, e := json.Marshal(errlog)
if e == nil {
return string(res), nil
}
return "", e
} | |
c18370 | err := ErrInternalServerError.WithMsg(e.Error())
if len(code) > 0 && code[0] > 0 {
err = err.WithCode(code[0])
}
return err
}
} | |
c18371 | = ErrInternalServerError.WithMsgf("%#v", v)
}
if err.Stack == "" {
buf := make([]byte, 2048)
buf = buf[:runtime.Stack(buf, false)]
s := 1
if len(skip) != 0 {
s = skip[0]
}
err.Stack = pruneStack(buf, s)
}
return err
} | |
c18372 | with SetOutput method"))
}
s.phrases = append(s.phrases, []byte(err))
} | |
c18373 |
return zlib.NewReader(r)
default:
return nil, ErrUnsupportedMediaType.WithMsgf("Unsupported Content-Encoding: %s", encoding)
}
} | |
c18374 | We just
// treat this request as an invalid preflighted request, so terminate the
// following steps.
if requestMethod == "" {
ctx.Res.Del(gear.HeaderAccessControlAllowOrigin)
ctx.Res.Del(gear.HeaderAccessControlAllowCredentials)
return ctx.End(http.StatusOK)
}
if len(opts.AllowMethods) > 0 ... | |
c18375 | return string(res), nil
}
return "", err
} | |
c18376 | WarningLevel, nil
case "NOTICE":
return NoticeLevel, nil
case "INFO":
return InfoLevel, nil
case "DEBUG":
return DebugLevel, nil
}
var l Level
return l, fmt.Errorf("not a valid gear logging Level: %q", lvl)
} | |
c18377 | > 0 && devMode[0] {
std.SetLogConsume(developmentConsume)
}
return std
} | |
c18378 | {
l.Output(time.Now(), EmergLevel, formatError(v))
} | |
c18379 | {
l.Output(time.Now(), AlertLevel, formatError(v))
}
} | |
c18380 | {
l.Output(time.Now(), CritiLevel, formatError(v))
}
} | |
c18381 | {
l.Output(time.Now(), ErrLevel, formatError(v))
}
} | |
c18382 | {
l.Output(time.Now(), WarningLevel, format(v))
}
} | |
c18383 | {
l.Output(time.Now(), NoticeLevel, format(v))
}
} | |
c18384 | {
l.Output(time.Now(), InfoLevel, format(v))
}
} | |
c18385 | {
l.Output(time.Now(), DebugLevel, format(v))
}
} | |
c18386 | {
l.Output(time.Now(), DebugLevel, fmt.Sprintf(format, args...))
}
} | |
c18387 | format(v)
l.Emerg(s)
panic(s)
} | |
c18388 | defer l.mu.Unlock()
fmt.Fprint(l.Out, args...)
} | |
c18389 | defer l.mu.Unlock()
fmt.Fprintf(l.Out, format, args...)
} | |
c18390 | defer l.mu.Unlock()
fmt.Fprintln(l.Out, args...)
} | |
c18391 | fmt.Fprintf(l.Out, l.lf, t.UTC().Format(l.tf), level.String(), crlfEscaper.Replace(s))
if err == nil {
l.Out.Write([]byte{'\n'})
}
return
} | |
c18392 | defer l.mu.Unlock()
return l.l
} | |
c18393 |
if level > DebugLevel {
panic(gear.Err.WithMsg("invalid logger level"))
}
l.l = level
return l
} | |
c18394 |
defer l.mu.Unlock()
l.init = fn
return l
} | |
c18395 | error) {
log := Log{}
l.init(log, ctx)
return log, nil
} | |
c18396 | _ := ctx.Any(l)
return any.(Log)
} | |
c18397 | if err := c.Do(ctx, req, &datasets); err != nil {
return nil, err
}
return datasets, nil
} | |
c18398 | return nil, err
}
if err := c.Do(ctx, req, &files); err != nil {
return nil, err
}
return files, nil
} | |
c18399 | if err := c.Do(ctx, req, &alerts); err != nil {
return nil, err
}
return alerts, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.