_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.Close()
return ioutil.ReadAll(res.Body)
} | 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 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
} | 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{}
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 err
}
}
return nil
} | 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:
return ErrProxyAuthRequired
case 408:
return ErrRequestTimeout
case 409:
return ErrConflict
case 410:
return ErrGone
case 411:
return ErrLengthRequired
case 412:
return ErrPreconditionFailed
case 413:
return ErrRequestEntityTooLarge
case 414:
return ErrRequestURITooLong
case 415:
return ErrUnsupportedMediaType
case 416:
return ErrRequestedRangeNotSatisfiable
case 417:
return ErrExpectationFailed
case 418:
return ErrTeapot
case 421:
return ErrMisdirectedRequest
case 422:
return ErrUnprocessableEntity
case 423:
return ErrLocked
case 424:
return ErrFailedDependency
case 426:
return ErrUpgradeRequired
case 428:
return ErrPreconditionRequired
case 429:
return ErrTooManyRequests
case 431:
return ErrRequestHeaderFieldsTooLarge
case 451:
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 ErrHTTPVersionNotSupported
case 506:
return ErrVariantAlsoNegotiates
case 507:
return ErrInsufficientStorage
case 508:
return ErrLoopDetected
case 510:
return ErrNotExtended
case 511:
return ErrNetworkAuthenticationRequired
default:
return Err.WithCode(status)
}
} | 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 == nil {
// FixedPathRedirect or TrailingSlashRedirect
if matched.TSR != "" || matched.FPR != "" {
ctx.Req.URL.Path = matched.TSR
if matched.FPR != "" {
ctx.Req.URL.Path = matched.FPR
}
if len(r.root) > 1 {
ctx.Req.URL.Path = r.root + ctx.Req.URL.Path[1:]
}
code := http.StatusMovedPermanently
if method != "GET" {
code = http.StatusTemporaryRedirect
}
ctx.Status(code)
return ctx.Redirect(ctx.Req.URL.String())
}
if r.otherwise == nil {
return nil
}
handler = r.otherwise
} else {
ok := false
if handler, ok = matched.Node.GetHandler(method).(Middleware); !ok {
// 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 ErrMethodNotAllowed.WithMsgf(`"%s" is not allowed in "%s"`, method, ctx.Path)
}
handler = r.otherwise
}
}
ctx.SetAny(paramsKey, matched.Params)
ctx.SetAny(routerNodeKey, matched.Node)
ctx.SetAny(routerRootKey, r.rt)
if len(r.mds) > 0 {
handler = Compose(r.middleware, handler)
}
return handler(ctx)
} | 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.MethodHead {
status := 200
if ctx.Method != http.MethodOptions {
status = 405
}
ctx.SetHeader(gear.HeaderContentType, "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
}
} | 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{}),
}
if app.serverName != "" {
ctx.SetHeader(HeaderServer, app.serverName)
}
if app.timeout <= 0 {
ctx.ctx, ctx.cancelCtx = context.WithCancel(r.Context())
} else {
ctx.ctx, ctx.cancelCtx = context.WithTimeout(r.Context(), app.timeout)
}
ctx.ctx = 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
} | 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, ','); i >= 0 {
ip = ip[0:i]
}
if realIP := net.ParseIP(ip); realIP != nil {
return realIP
}
}
ra := ctx.Req.RemoteAddr
ra, _, _ = net.SplitHostPort(ra)
return net.ParseIP(ra)
} | 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-rosetta-flash/
// the typeof check is just to reduce client error noise
b := []byte(fmt.Sprintf(`/**/ typeof %s === "function" && %s(`, callback, callback))
b = append(b, buf...)
return ctx.End(code, append(b, ')', ';'))
} | 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, dispositionType))
http.ServeContent(ctx.Res, ctx.Req, name, modtime, content)
} else {
err = ErrInternalServerError.WithMsg("request ended before ctx.Attachment")
}
return
} | 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
}
return nil
}
} | 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 {
return nil
}
if ute, ok := err.(*json.UnmarshalTypeError); ok {
if ute.Field == "" { // go1.11
return fmt.Errorf("Unmarshal type error: expected=%v, got=%v, offset=%v",
ute.Type, ute.Value, ute.Offset)
}
return fmt.Errorf("Unmarshal type error: field=%v, expected=%v, got=%v, offset=%v",
ute.Field, ute.Type, ute.Value, ute.Offset)
} 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 := url.ParseQuery(string(buf))
if err == nil {
err = ValuesToStruct(val, body, "form")
}
return err
}
return ErrUnsupportedMediaType.WithMsg("unsupported media type")
} | 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.Set(SetBodyParser, DefaultBodyParser(2<<20)) // 2MB
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
} | 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("[%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())
}
}
} | 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 {
err = err.WithCode(code[0])
}
return err
}
} | 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 = ErrInternalServerError.WithMsg(v)
default:
err = 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
} | 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, ErrUnsupportedMediaType.WithMsgf("Unsupported Content-Encoding: %s", encoding)
}
} | 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.AllowOriginsValidator = func(origin string, _ *gear.Context) (allowOrigin string) {
for _, o := range opts.AllowOrigins {
if o == origin || o == "*" {
allowOrigin = origin
break
}
}
return
}
}
return func(ctx *gear.Context) (err error) {
// Always set Vary, see https://github.com/rs/cors/issues/10
ctx.Res.Vary(gear.HeaderOrigin)
origin := ctx.GetHeader(gear.HeaderOrigin)
// not a CORS request
if origin == "" {
return
}
allowOrigin := opts.AllowOriginsValidator(origin, ctx)
if allowOrigin == "" {
// If the request Origin header is not allowed. Just terminate the following steps.
if ctx.Method == http.MethodOptions {
return ctx.End(http.StatusOK)
}
return
}
ctx.SetHeader(gear.HeaderAccessControlAllowOrigin, allowOrigin)
if opts.Credentials {
// when responding to a credentialed request, server must specify a
// domain, and cannot use wild carding.
// See *important note* in https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials .
ctx.SetHeader(gear.HeaderAccessControlAllowCredentials, "true")
}
// Handle preflighted requests (https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Preflighted_requests) .
// https://stackoverflow.com/questions/46026409/what-are-proper-status-codes-for-cors-preflight-requests
if ctx.Method == http.MethodOptions {
ctx.Res.Vary(gear.HeaderAccessControlRequestMethod)
ctx.Res.Vary(gear.HeaderAccessControlRequestHeaders)
requestMethod := ctx.GetHeader(gear.HeaderAccessControlRequestMethod)
// If there is no "Access-Control-Request-Method" request header. 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 {
ctx.SetHeader(gear.HeaderAccessControlAllowMethods, strings.Join(opts.AllowMethods, ", "))
}
var allowHeaders string
if len(opts.AllowHeaders) > 0 {
allowHeaders = strings.Join(opts.AllowHeaders, ", ")
} else {
allowHeaders = ctx.GetHeader(gear.HeaderAccessControlRequestHeaders)
}
if allowHeaders != "" {
ctx.SetHeader(gear.HeaderAccessControlAllowHeaders, allowHeaders)
}
if opts.MaxAge > 0 {
ctx.SetHeader(gear.HeaderAccessControlMaxAge, strconv.Itoa(int(opts.MaxAge.Seconds())))
}
return ctx.End(http.StatusOK)
}
if len(opts.ExposeHeaders) > 0 {
ctx.SetHeader(gear.HeaderAccessControlExposeHeaders, strings.Join(opts.ExposeHeaders, ", "))
}
return
}
} | 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, 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)
} | 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'})
}
return
} | 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 nil, err
}
return files, nil
} | 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.