_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q19600 | HTTP | train | func (r *Router) HTTP() *Router {
if r.root != nil {
return r.root.HTTP()
}
r.mu.Lock()
if r.httprouter == nil {
r.httprouter = &Router{
router: newRouter(),
app: r.app,
root: r,
}
}
r.mu.Unlock()
return r.httprouter
} | go | {
"resource": ""
} |
q19601 | HTTPS | train | func (r *Router) HTTPS() *Router {
if r.root != nil {
return r.root.HTTPS()
}
r.mu.Lock()
if r.httpsrouter == nil {
r.httpsrouter = &Router{
router: newRouter(),
app: r.app,
root: r,
}
}
r.mu.Unlock()
return r.httpsrouter
} | go | {
"resource": ""
} |
q19602 | Si | train | func Si(n uint64) string {
suff := siRaw
x := float64(n)
for ; x >= 1024; x = x / 1024 {
suff++
}
return fmt.Sprintf("%.2f%s", x, suff.String())
} | go | {
"resource": ""
} |
q19603 | HealthHandler | train | func (app *App) HealthHandler(ctx *Context) {
var m runtime.MemStats
runtime.ReadMemStats(&m)
e := ctx.JSON(m)
_ = e
} | go | {
"resource": ""
} |
q19604 | AddServiceServer | train | func (i *Infrastructure) AddServiceServer(serviceName string, addr Address) error {
i.Lock.RLock()
if _, ok := i.Services[serviceName]; !ok {
i.Lock.RUnlock()
return ErrServiceNotExists
}
i.Lock.RUnlock()
i.Lock.Lock()
if i.Services[serviceName].Addresses == nil {
i.Services[serviceName].Addresses = make([]Address, 0)
}
i.UpdateTimestamp = time.Now().UnixNano()
i.Services[serviceName].Addresses = append(i.Services[serviceName].Addresses, addr)
i.Lock.Unlock()
return nil
} | go | {
"resource": ""
} |
q19605 | Register | train | func Register(app *gramework.App, serviceName ...string) error {
var m Middleware
name := os.Args[0]
if len(serviceName) > 0 {
name = serviceName[0]
}
hostname, err := os.Hostname()
if err != nil {
return err
}
m.httpReqCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "gramework_http_requests_total",
Help: "Total count of HTTP requests processed, partitioned by code, method, path and type (HTTP/HTTPS)",
ConstLabels: prometheus.Labels{
"service": name,
"node": hostname,
},
},
[]string{"code", "method", "path", "type"},
)
if err = prometheus.Register(m.httpReqCounter); err != nil {
return err
}
m.reqDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Name: "gramework_http_requests_duration_seconds",
Help: "Request processing duration, partitioned by code, method, path and type (HTTP/HTTPS)",
ConstLabels: prometheus.Labels{
"service": name,
"node": hostname,
},
},
[]string{"code", "method", "path", "type"},
)
if err = prometheus.Register(m.reqDuration); err != nil {
return err
}
app.GET(string(metricsPath), gramework.NewGrameHandler(promhttp.Handler()))
if err = app.UsePre(m.startReq); err != nil {
return err
}
return app.UseAfterRequest(m.endReq)
} | go | {
"resource": ""
} |
q19606 | SetCookieExpire | train | func (app *App) SetCookieExpire(d time.Duration) {
if d != 0 {
app.cookieExpire = d
}
} | go | {
"resource": ""
} |
q19607 | SetSanitizerPolicy | train | func (app *App) SetSanitizerPolicy(newPolicy *bluemonday.Policy) {
if newPolicy != nil {
app.sanitizerPolicy = newPolicy
}
} | go | {
"resource": ""
} |
q19608 | Shutdown | train | func (app *App) Shutdown() (err error) {
app.runningServersMu.Lock()
// this is not a hot path, we can freely use defer here
defer app.runningServersMu.Unlock()
newRunningList := []runningServerInfo{}
for _, info := range app.runningServers {
app.internalLog.WithField("bind", info.bind).Warn("shutting down server")
err = info.srv.Shutdown()
if err != nil {
app.internalLog.WithError(err).Error("could not shutdown server")
newRunningList = append(newRunningList, info)
continue
}
}
app.runningServers = newRunningList
if err == nil {
app.internalLog.Warn("application servers shutted down successfully")
return
}
app.internalLog.WithError(err).WithField("stillRunning", len(app.runningServers)).Warn("could not stop servers")
return
} | go | {
"resource": ""
} |
q19609 | New | train | func New(opts ...Option) *Unwrapper {
a := &Unwrapper{
ipHeader: DefaultAkamaiIPHeader,
}
for _, opt := range opts {
opt(a)
}
return a
} | go | {
"resource": ""
} |
q19610 | toLower | train | func toLower(s string) string {
isASCII, hasUpper := true, false
for i := 0; i < len(s); i++ {
c := s[i]
if c >= utf8.RuneSelf {
isASCII = false
break
}
hasUpper = hasUpper || (c >= 'A' && c <= 'Z')
}
if isASCII { // optimize for ASCII-only strings.
if !hasUpper {
return s
}
var b strings.Builder
b.Grow(len(s))
for i := 0; i < len(s); i++ {
c := s[i]
if c >= 'A' && c <= 'Z' {
c += 'a' - 'A'
}
b.WriteByte(c)
}
return b.String()
}
return stringsMap(unicode.ToLower, s)
} | go | {
"resource": ""
} |
q19611 | stringsMap | train | func stringsMap(mapping func(rune) rune, s string) string {
// In the worst case, the string can grow when mapped, making
// things unpleasant. But it's so rare we barge in assuming it's
// fine. It could also shrink but that falls out naturally.
// The output buffer b is initialized on demand, the first
// time a character differs.
var b strings.Builder
for i, c := range s {
r := mapping(c)
if r == c {
continue
}
b.Grow(len(s) + utf8.UTFMax)
b.WriteString(s[:i])
if r >= 0 {
b.WriteRune(r)
}
if c == utf8.RuneError {
// RuneError is the result of either decoding
// an invalid sequence or '\uFFFD'. Determine
// the correct number of bytes we need to advance.
_, w := utf8.DecodeRuneInString(s[i:])
i += w
} else {
i += utf8.RuneLen(c)
}
s = s[i:]
break
}
// Fast path for unchanged input
if b.Cap() == 0 { // didn't call b.Grow above
return s
}
for _, c := range s {
r := mapping(c)
if r >= 0 {
// common case
// Due to inlining, it is more performant to determine if WriteByte should be
// invoked rather than always call WriteRune
if r < utf8.RuneSelf {
b.WriteByte(byte(r))
} else {
// r is not a ASCII rune.
b.WriteRune(r)
}
}
}
return b.String()
} | go | {
"resource": ""
} |
q19612 | RegisterService | train | func (i *Infrastructure) RegisterService(name string, s Service) error {
i.Lock.RLock()
if _, ok := i.Services[name]; ok {
i.Lock.RUnlock()
return ErrServiceExists
}
i.Lock.RUnlock()
i.Lock.Lock()
if s.Name == "" {
s.Name = name
}
i.Services[name] = &s
i.Lock.Unlock()
return nil
} | go | {
"resource": ""
} |
q19613 | MergeService | train | func (i *Infrastructure) MergeService(name string, s Service) {
i.Lock.Lock()
if _, ok := i.Services[name]; ok {
i.Services[name].Addresses = append(i.Services[name].Addresses, s.Addresses...)
i.Lock.Unlock()
return
}
i.Services[name] = &s
i.Lock.Unlock()
} | go | {
"resource": ""
} |
q19614 | SetEnv | train | func SetEnv(e Environment) {
if e != DEV && e != STAGE && e != PROD {
internalLog.Warn("could not set unknown environment value, ignoring")
return
}
if e != GetEnv() {
internalLog.
WithField("prevEnv", GetEnv()).
WithField("newEnv", e).
Warn("Setting a new environment")
}
if e == PROD {
Logger.Level = log.InfoLevel
enableDebug = false
} else {
enableDebug = true
Logger.Level = log.DebugLevel
}
atomic.StoreInt32(currentEnvironment, int32(e))
} | go | {
"resource": ""
} |
q19615 | ListenAndServeAutoTLS | train | func (app *App) ListenAndServeAutoTLS(addr string, cachePath ...string) error {
if len(app.TLSEmails) == 0 {
return ErrTLSNoEmails
}
addr, err := normalizeTLSAddr(addr)
if err != nil {
app.internalLog.Errorf("Bad address %q: %s", addr, err)
}
ln, err := net.Listen("tcp", addr)
if err != nil {
app.internalLog.Errorf("Can't serve %q: %s", addr, err)
return err
}
letscache := getCachePath()
if len(cachePath) > 0 {
letscache = cachePath[0]
}
s := rand.NewSource(time.Now().Unix())
r := rand.New(s)
m := autocert.Manager{
Prompt: autocert.AcceptTOS,
Email: app.TLSEmails[r.Intn(len(app.TLSEmails))],
}
if letscache != "" {
m.Cache = autocert.DirCache(letscache)
}
tlsConfig := getDefaultTLSConfig()
tlsConfig.GetCertificate = func(hello *tls.ClientHelloInfo) (cert *tls.Certificate, err error) {
if len(hello.ServerName) == 0 || hello.ServerName == localhost {
hello.ServerName = localhost
cert, err = selfSignedCertificate(hello)
} else {
cert, err = m.GetCertificate(hello)
}
if err != nil {
app.internalLog.Errorf("Can't get cert for %q: %s", hello.ServerName, err)
}
return cert, err
}
tlsLn := tls.NewListener(ln, tlsConfig)
l := app.internalLog.WithField("bind", addr)
l.Info("Starting HTTPS")
srv := app.copyServer()
app.runningServersMu.Lock()
app.runningServers = append(app.runningServers, runningServerInfo{
bind: addr,
srv: srv,
})
app.runningServersMu.Unlock()
if err = srv.Serve(tlsLn); err != nil {
app.internalLog.Errorf("Can't serve: %s", err)
}
return err
} | go | {
"resource": ""
} |
q19616 | Column | train | func (tb *CreateTableBuilder) Column(name string) *ColumnBuilder {
return &ColumnBuilder{
tableBuilder: tb,
name: name,
}
} | go | {
"resource": ""
} |
q19617 | appendColumn | train | func (tb *CreateTableBuilder) appendColumn(c *tableColumn) *CreateTableBuilder {
tb.columns = append(tb.columns, *c)
return tb
} | go | {
"resource": ""
} |
q19618 | New | train | func New(config Config) *Instance {
client := &Instance{
conf: &config,
clients: make(map[string]*fasthttp.HostClient),
clientsMu: new(sync.RWMutex),
balancer: newRangeBalancer(),
}
return client
} | go | {
"resource": ""
} |
q19619 | Equals | train | func (p *scryptParams) Equals(p1 *scryptParams) bool {
return p.keyLen == p1.keyLen &&
p.n == p1.n &&
p.r == p1.r &&
p.p == p1.p &&
p.saltLen == p1.saltLen
} | go | {
"resource": ""
} |
q19620 | String | train | func (p *scryptParams) String() string {
return fmt.Sprintf(paramsFmt, p.keyLen, p.n, p.r, p.p, p.saltLen)
} | go | {
"resource": ""
} |
q19621 | New | train | func New() *Provider {
return &Provider{
params: &scryptParams{
keyLen: DefaultKeyLen,
n: DefaultN,
r: DefaultR,
p: DefaultP,
saltLen: DefaultSaltLen,
},
}
} | go | {
"resource": ""
} |
q19622 | HashString | train | func (p *Provider) HashString(plaintext string) []byte {
return p.Hash([]byte(plaintext))
} | go | {
"resource": ""
} |
q19623 | Encode | train | func (ctx *Context) Encode(v interface{}) (string, error) {
accept := ctx.Request.Header.Peek(acceptHeader)
accepted := acceptParser.Parse(BytesToString(accept))
sentType, err := accepted.Negotiate(ctypes...)
if err != nil {
return emptyString, err
}
switch sentType {
case jsonCT:
err = ctx.JSON(v)
case xmlCT:
err = ctx.XML(v)
case csvCT:
err = ctx.CSV(v)
}
return sentType, err
} | go | {
"resource": ""
} |
q19624 | HTML | train | func (ctx *Context) HTML(src ...string) *Context {
ctx.SetContentType(htmlCT)
if len(src) > 0 {
_, e := ctx.WriteString(src[0])
_ = e
}
return ctx
} | go | {
"resource": ""
} |
q19625 | CORS | train | func (ctx *Context) CORS(domains ...string) *Context {
var origins []string
if len(domains) > 0 {
origins = domains
} else if headerOrigin := ctx.Request.Header.Peek(hOrigin); len(headerOrigin) > 0 {
origins = append(origins, string(headerOrigin))
} else {
origins = append(origins, string(ctx.Request.URI().Host()))
}
ctx.Response.Header.Set(corsAccessControlAllowOrigin, strings.Join(origins, " "))
ctx.Response.Header.Set(corsAccessControlAllowMethods, methods)
ctx.Response.Header.Set(corsAccessControlAllowHeaders, corsCType)
ctx.Response.Header.Set(corsAccessControlAllowCredentials, trueStr)
return ctx
} | go | {
"resource": ""
} |
q19626 | JSON | train | func (ctx *Context) JSON(v interface{}) error {
ctx.SetContentType(jsonCT)
b, err := ctx.ToJSON(v)
if err != nil {
return err
}
_, err = ctx.Write(b)
return err
} | go | {
"resource": ""
} |
q19627 | Err500 | train | func (ctx *Context) Err500(message ...interface{}) *Context {
ctx.SetStatusCode(fasthttp.StatusInternalServerError)
for k := range message {
switch v := message[k].(type) {
case string:
_, err := ctx.WriteString(v)
if err != nil {
ctx.Logger.WithError(err).Error("Err500 serving error")
}
case error:
_, e := ctx.Writef(fmtS, v)
_ = e // it's already 500
default:
_, e := ctx.Writef(fmtV, v)
_ = e
}
}
return ctx
} | go | {
"resource": ""
} |
q19628 | JSONError | train | func (ctx *Context) JSONError(v interface{}) error {
ctx.Err500()
return ctx.JSON(v)
} | go | {
"resource": ""
} |
q19629 | PasswordValid | train | func PasswordValid(hash, password []byte) bool {
p := matchProvider(hash)
if p == nil {
return false
}
return p.Valid(hash, password)
} | go | {
"resource": ""
} |
q19630 | OptAppName | train | func OptAppName(n string) func(*App) {
return func(app *App) {
assertAppNotNill(app)
app.name = n
}
} | go | {
"resource": ""
} |
q19631 | OptUseCustomLogger | train | func OptUseCustomLogger(logger *log.Logger) func(*App) {
return func(app *App) {
assertAppNotNill(app)
app.Logger = logger
}
} | go | {
"resource": ""
} |
q19632 | OptUseServer | train | func OptUseServer(s *fasthttp.Server) func(*App) {
return func(app *App) {
assertAppNotNill(app)
if s == nil {
panic(errors.New("cannot set nil as app server instance"))
}
app.serverBase = s
app.serverBase.Handler = app.handler()
}
} | go | {
"resource": ""
} |
q19633 | OptMaxRequestBodySize | train | func OptMaxRequestBodySize(size int) func(*App) {
return func(app *App) {
assertAppNotNill(app)
if app.serverBase == nil {
app.serverBase = newDefaultServerBaseFor(app)
}
app.serverBase.MaxRequestBodySize = size
}
} | go | {
"resource": ""
} |
q19634 | OptKeepHijackedConns | train | func OptKeepHijackedConns(keep bool) func(*App) {
return func(app *App) {
assertAppNotNill(app)
if app.serverBase == nil {
app.serverBase = newDefaultServerBaseFor(app)
}
app.serverBase.KeepHijackedConns = keep
}
} | go | {
"resource": ""
} |
q19635 | Integer | train | func (cb *ColumnBuilder) Integer() *CreateTableBuilder {
return cb.tableBuilder.appendColumn(&tableColumn{
name: cb.name,
sqlType: "INTEGER",
})
} | go | {
"resource": ""
} |
q19636 | newRouter | train | func newRouter() *router {
r := &router{
RedirectTrailingSlash: true,
RedirectFixedPath: true,
HandleMethodNotAllowed: true,
HandleOPTIONS: true,
cache: &cache{
v: map[string]*msc{
// init default methods
MethodGET: &msc{
v: make(map[string]*cacheRecord),
},
MethodDELETE: &msc{
v: make(map[string]*cacheRecord),
},
MethodHEAD: &msc{
v: make(map[string]*cacheRecord),
},
MethodOPTIONS: &msc{
v: make(map[string]*cacheRecord),
},
MethodPATCH: &msc{
v: make(map[string]*cacheRecord),
},
MethodPOST: &msc{
v: make(map[string]*cacheRecord),
},
MethodPUT: &msc{
v: make(map[string]*cacheRecord),
},
},
},
}
r.StaticHandlers = map[methodIndex]map[string]staticHandler{
methodToIdx(GET): make(map[string]staticHandler),
methodToIdx(DELETE): make(map[string]staticHandler),
methodToIdx(HEAD): make(map[string]staticHandler),
methodToIdx(OPTIONS): make(map[string]staticHandler),
methodToIdx(PATCH): make(map[string]staticHandler),
methodToIdx(POST): make(map[string]staticHandler),
methodToIdx(PUT): make(map[string]staticHandler),
}
go r.cache.maintain()
return r
} | go | {
"resource": ""
} |
q19637 | Recv | train | func (r *router) Recv(ctx *Context, tracer *log.Entry) {
if rcv := recover(); rcv != nil {
if r.PanicHandler != nil {
r.PanicHandler(ctx, rcv)
} else {
DefaultPanicHandler(ctx, rcv)
}
if tracer != nil {
tracer.WithFields(log.Fields{
"reason": rcv,
"code": ctx.Response.StatusCode(),
}).Error("request caused panic")
}
}
} | go | {
"resource": ""
} |
q19638 | ContentType | train | func (ctx *Context) ContentType() string {
return string(ctx.Request.Header.Peek(contentType))
} | go | {
"resource": ""
} |
q19639 | RouteArg | train | func (ctx *Context) RouteArg(argName string) string {
v, err := ctx.RouteArgErr(argName)
if err != nil {
return emptyString
}
return v
} | go | {
"resource": ""
} |
q19640 | ToXML | train | func (ctx *Context) ToXML(v interface{}) ([]byte, error) {
b := bytes.NewBuffer(nil)
err := xml.NewEncoder(b).Encode(v)
return b.Bytes(), err
} | go | {
"resource": ""
} |
q19641 | RouteArgErr | train | func (ctx *Context) RouteArgErr(argName string) (string, error) {
i := ctx.UserValue(argName)
if i == nil {
return emptyString, ErrArgNotFound
}
switch value := i.(type) {
case string:
return value, nil
default:
return fmt.Sprintf(fmtV, i), nil
}
} | go | {
"resource": ""
} |
q19642 | ToTLS | train | func (ctx *Context) ToTLS() {
u := ctx.URI()
u.SetScheme(https)
ctx.Redirect(u.String(), redirectCode)
} | go | {
"resource": ""
} |
q19643 | ToJSON | train | func (ctx *Context) ToJSON(v interface{}) ([]byte, error) {
b := bytes.NewBuffer(nil)
enc := ffjson.NewEncoder(b)
err := enc.Encode(v)
return b.Bytes(), err
} | go | {
"resource": ""
} |
q19644 | UnJSON | train | func (ctx *Context) UnJSON(v interface{}) error {
return ffjson.NewDecoder().Decode(ctx.Request.Body(), &v)
} | go | {
"resource": ""
} |
q19645 | NewCacheOptions | train | func NewCacheOptions() *CacheOptions {
return &CacheOptions{
TTL: 30 * time.Second,
Cacheable: func(ctx *Context) bool {
if len(ctx.Request.Header.Peek("Authentication")) > 0 {
return false
}
if len(ctx.Cookies.Storage) > 0 {
return false
}
return true
},
CacheKey: func(ctx *Context) []byte {
return ctx.Path()
},
}
} | go | {
"resource": ""
} |
q19646 | WSHandler | train | func (client *Instance) WSHandler() func(*gramework.Context) error {
up := websocket.FastHTTPUpgrader{}
return func(ctx *gramework.Context) error {
if websocket.FastHTTPIsWebSocketUpgrade(ctx.RequestCtx) {
return up.Upgrade(ctx.RequestCtx, func(conn *websocket.Conn) {
for {
v := <-client.watch(ctx)
err := conn.WriteMessage(websocket.TextMessage, v)
if err != nil {
break
}
}
})
}
return client.handleHTTP(ctx)
}
} | go | {
"resource": ""
} |
q19647 | FindCaseInsensitivePath | train | func (n *node) FindCaseInsensitivePath(path string, fixTrailingSlash bool) ([]byte, bool) {
return n.findCaseInsensitivePathRec(
path,
toLower(path),
make([]byte, zero, len(path)+one), // preallocate enough memory for new path
[4]byte{}, // empty rune buffer
fixTrailingSlash,
)
} | go | {
"resource": ""
} |
q19648 | Table | train | func (cb *CreateBuilder) Table(name string) *CreateTableBuilder {
return &CreateTableBuilder{
name: name,
columns: make([]tableColumn, 0),
}
} | go | {
"resource": ""
} |
q19649 | Domain | train | func (app *App) Domain(domain string) *Router {
app.domainListLock.Lock()
if app.domains[domain] == nil {
app.domains[domain] = &Router{
router: newRouter(),
app: app,
}
}
app.domainListLock.Unlock()
return app.domains[domain]
} | go | {
"resource": ""
} |
q19650 | ServeDir | train | func (app *App) ServeDir(path string) func(*Context) {
return app.ServeDirCustom(path, 0, true, false, []string{"index.html", "index.htm"})
} | go | {
"resource": ""
} |
q19651 | ServeDirCustom | train | func (app *App) ServeDirCustom(path string, stripSlashes int, compress bool, generateIndexPages bool, indexNames []string) func(*Context) {
if indexNames == nil {
indexNames = []string{}
}
fs := &fasthttp.FS{
Root: path,
IndexNames: indexNames,
GenerateIndexPages: generateIndexPages,
Compress: compress,
CacheDuration: 5 * time.Minute,
CompressedFileSuffix: ".gz",
}
if stripSlashes > 0 {
fs.PathRewrite = fasthttp.NewPathSlashesStripper(stripSlashes)
}
h := fs.NewRequestHandler()
return func(ctx *Context) {
h(ctx.RequestCtx)
}
} | go | {
"resource": ""
} |
q19652 | ServeDirNoCache | train | func (app *App) ServeDirNoCache(path string) func(*Context) {
return app.ServeDirNoCacheCustom(path, 0, true, false, nil)
} | go | {
"resource": ""
} |
q19653 | ServeDirNoCacheCustom | train | func (app *App) ServeDirNoCacheCustom(path string, stripSlashes int, compress bool, generateIndexPages bool, indexNames []string) func(*Context) {
if indexNames == nil {
indexNames = []string{}
}
fs := &fasthttp.FS{
Root: path,
IndexNames: indexNames,
GenerateIndexPages: generateIndexPages,
Compress: compress,
CacheDuration: time.Millisecond,
CompressedFileSuffix: ".gz",
}
if stripSlashes > 0 {
fs.PathRewrite = fasthttp.NewPathSlashesStripper(stripSlashes)
}
h := fs.NewRequestHandler()
pragmaH := "Pragma"
pragmaV := "no-cache"
expiresH := "Expires"
expiresV := "0"
ccH := "Cache-Control"
ccV := "no-cache, no-store, must-revalidate"
return func(ctx *Context) {
ctx.Response.Header.Add(pragmaH, pragmaV)
ctx.Response.Header.Add(expiresH, expiresV)
ctx.Response.Header.Add(ccH, ccV)
h(ctx.RequestCtx)
}
} | go | {
"resource": ""
} |
q19654 | AddFlag | train | func (app *App) AddFlag(f Flag) {
if app.flagsQueue == nil {
app.flagsQueue = make([]Flag, 0)
}
app.flagsQueue = append(app.flagsQueue, f)
} | go | {
"resource": ""
} |
q19655 | RegFlags | train | func (app *App) RegFlags() {
if app.Flags.values == nil {
app.Flags.values = make(map[string]Flag)
}
app.flagsRegistered = true
for _, v := range app.flagsQueue {
app.Flags.values[v.Name] = Flag{
Name: v.Name,
Description: v.Description,
Default: v.Default,
Value: flag.String(v.Name, v.Default, v.Description),
}
}
} | go | {
"resource": ""
} |
q19656 | GetStringFlag | train | func (app *App) GetStringFlag(name string) (string, bool) {
if !flag.Parsed() && !flagsDisabled {
flag.Parse()
}
if app.Flags.values != nil {
if bindFlag, ok := app.Flags.values[name]; ok {
return *bindFlag.Value, ok
}
}
return "", false
} | go | {
"resource": ""
} |
q19657 | Use | train | func (app *App) Use(middleware interface{}) error {
if middleware == nil {
return ErrEmptyMiddleware
}
processor, err := app.middlewareProcessor(middleware)
app.middlewaresMu.Lock()
if err == nil {
app.middlewares = append(app.middlewares, processor)
}
app.middlewaresMu.Unlock()
return err
} | go | {
"resource": ""
} |
q19658 | UsePre | train | func (app *App) UsePre(middleware interface{}) error {
if middleware == nil {
return ErrEmptyMiddleware
}
processor, err := app.middlewareProcessor(middleware)
app.preMiddlewaresMu.Lock()
if err == nil {
app.preMiddlewares = append(app.preMiddlewares, processor)
}
app.preMiddlewaresMu.Unlock()
return err
} | go | {
"resource": ""
} |
q19659 | UseAfterRequest | train | func (app *App) UseAfterRequest(middleware interface{}) error {
if middleware == nil {
return ErrEmptyMiddleware
}
processor, err := app.middlewareProcessor(middleware)
app.middlewaresAfterRequestMu.Lock()
if err == nil {
app.middlewaresAfterRequest = append(app.middlewaresAfterRequest, processor)
}
app.middlewaresAfterRequestMu.Unlock()
return nil
} | go | {
"resource": ""
} |
q19660 | LogHeaders | train | func (ctx *Context) LogHeaders() {
ctx.Request.Header.VisitAll(func(k, v []byte) {
ctx.Logger.Debugf("%s = [%s]\n", k, v)
})
} | go | {
"resource": ""
} |
q19661 | Proxy | train | func (ctx *Context) Proxy(url string) (err error) {
proxyReq := fasthttp.AcquireRequest()
ctx.Request.CopyTo(proxyReq)
proxyReq.SetRequestURI(url)
err = fasthttp.Do(proxyReq, &ctx.Response)
fasthttp.ReleaseRequest(proxyReq)
return
} | go | {
"resource": ""
} |
q19662 | Register | train | func Register(r interface{}, collectors ...func() (statKey string, stats interface{})) error {
return doReg(r, collectors, true, true)
} | go | {
"resource": ""
} |
q19663 | RegisterHealthcheck | train | func RegisterHealthcheck(r interface{}, collectors ...func() (statKey string, stats interface{})) error {
return doReg(r, collectors, false, true)
} | go | {
"resource": ""
} |
q19664 | New | train | func New() *Infrastructure {
return &Infrastructure{
Lock: new(sync.RWMutex),
Services: make(map[string]*Service),
UpdateTimestamp: time.Now().UnixNano(),
}
} | go | {
"resource": ""
} |
q19665 | IsPortInRange | train | func IsPortInRange(port string) bool {
if strings.Contains(port, ",") {
ports := strings.Split(port, ",")
for _, p := range ports {
if strings.Contains(p, "-") && IsPortInRange(p) {
return true
}
for _, allowedPort := range allowedPorts {
if p == allowedPort {
return true
}
}
}
return false
}
if strings.Contains(port, "-") {
portRange := strings.Split(port, "-")
if len(portRange) != 2 {
return false
}
min, err := strconv.Atoi(portRange[0])
if err != nil {
return false
}
max, err := strconv.Atoi(portRange[1])
if err != nil {
return false
}
for _, p := range allowedPortsInts {
if min <= p && max >= p {
return true
}
}
return false
}
for _, p := range allowedPorts {
if port == p {
return true
}
}
return false
} | go | {
"resource": ""
} |
q19666 | Insert | train | func Insert(table string) *InsertBuilder {
return &InsertBuilder{
tableName: table,
query: fmt.Sprintln(`INSERT INTO`, table),
lock: new(sync.Mutex),
}
} | go | {
"resource": ""
} |
q19667 | PreparedInsert | train | func PreparedInsert(table string) *InsertBuilder {
i := Insert(table)
i.prepared = true
return i
} | go | {
"resource": ""
} |
q19668 | Columns | train | func (b *InsertBuilder) Columns(columns ...string) *InsertBuilder {
b.lock.Lock()
b.columns = columns
b.query = fmt.Sprintf(`%s(`, b.query)
for i, column := range columns {
b.query = fmt.Sprintf(`%s%s`, b.query, column)
if i < len(columns)-1 {
b.query = fmt.Sprintf(`%s,`, b.query)
}
}
b.query = fmt.Sprintf(`%s)`, b.query)
b.lock.Unlock()
return b
} | go | {
"resource": ""
} |
q19669 | Values | train | func (b *InsertBuilder) Values(columnValues ...interface{}) *InsertBuilder {
b.lock.Lock()
sqlValue := "("
if b.prepared {
for k, columnValue := range columnValues {
switch v := columnValue.(type) {
case string:
sqlValue = fmt.Sprintf("%s'%s'", sqlValue, strings.Replace(v, "'", "''", -1))
default:
sqlValue = fmt.Sprintf("%s%v", sqlValue, v)
}
if k < len(columnValues)-1 {
sqlValue = fmt.Sprintf("%s, ", sqlValue)
}
}
} else {
for k := range columnValues {
sqlValue = fmt.Sprintf("%s?", sqlValue)
if k < len(columnValues)-1 {
sqlValue = fmt.Sprintf("%s, ", sqlValue)
}
}
}
b.sqlValues = append(b.sqlValues, fmt.Sprintf(`%s)`, sqlValue))
b.lock.Unlock()
return b
} | go | {
"resource": ""
} |
q19670 | Build | train | func (b *InsertBuilder) Build() string {
b.lock.Lock()
defer b.lock.Unlock()
return fmt.Sprintf("%s\n VALUES %s;", b.query, strings.Join(b.sqlValues, ", \n "))
} | go | {
"resource": ""
} |
q19671 | Handler | train | func Handler(ctx *gramework.Context) {
if _, err := ctx.HTML().WriteString(tpl); err != nil {
ctx.Logger.WithError(err).WithField("package", "mw/graphiql").Error("could not send template")
}
} | go | {
"resource": ""
} |
q19672 | GetCookieDomain | train | func (ctx *Context) GetCookieDomain() (domain string, wasConfigured bool) {
return ctx.App.cookieDomain, len(ctx.App.cookieDomain) > 0
} | go | {
"resource": ""
} |
q19673 | Set | train | func (c *Cookies) Set(key, value string) {
c.Mu.Lock()
if c.Storage == nil {
c.Storage = make(map[string]string, zero)
}
c.Storage[key] = value
c.Mu.Unlock()
} | go | {
"resource": ""
} |
q19674 | Get | train | func (c *Cookies) Get(key string) (string, bool) {
c.Mu.Lock()
if c.Storage == nil {
c.Storage = make(map[string]string, zero)
c.Mu.Unlock()
return emptyString, false
}
if v, ok := c.Storage[key]; ok {
c.Mu.Unlock()
return v, ok
}
c.Mu.Unlock()
return emptyString, false
} | go | {
"resource": ""
} |
q19675 | Exists | train | func (c *Cookies) Exists(key string) bool {
c.Mu.Lock()
if c.Storage == nil {
c.Storage = make(map[string]string, zero)
c.Mu.Unlock()
return false
}
if _, ok := c.Storage[key]; ok {
c.Mu.Unlock()
return ok
}
c.Mu.Unlock()
return false
} | go | {
"resource": ""
} |
q19676 | HTTP | train | func (r *SubRouter) HTTP() *SubRouter {
switch parent := r.parent.(type) {
case *SubRouter:
return parent.HTTP()
case *Router:
return &SubRouter{
parent: parent,
prefix: r.prefix,
}
default:
Errorf("[HIGH SEVERITY BUG]: unreachable case found! Expected *SubRouter or *Router, got %T! Returning nil!", parent)
Errorf("Please report the bug on https://github.com/gramework/gramework ASAP!")
return nil
}
} | go | {
"resource": ""
} |
q19677 | HTTPS | train | func (r *SubRouter) HTTPS() *SubRouter {
switch parent := r.parent.(type) {
case *SubRouter:
return parent.HTTPS()
case *Router:
return &SubRouter{
parent: parent,
prefix: r.prefix,
}
default:
Errorf("[HIGH SEVERITY BUG]: unreachable case found! Expected *SubRouter or *Router, got %T! Returning nil!", parent)
Errorf("Please report the bug on https://github.com/gramework/gramework ASAP!")
return nil
}
} | go | {
"resource": ""
} |
q19678 | DecodeGQL | train | func (ctx *Context) DecodeGQL() (*GQLRequest, error) {
r := &GQLRequest{}
if string(ctx.Method()) == GET {
query := ctx.GETParam("query")
if len(query) == 0 {
return nil, ErrInvalidGQLRequest
}
r.Query = query[0]
if operationName := ctx.GETParam("operationName"); len(operationName) != 0 {
r.OperationName = operationName[0]
}
if variables := ctx.GETParam("variables"); len(variables) != 0 {
if _, err := ctx.UnJSONBytes([]byte(variables[0]), &r.Variables); err != nil {
return nil, ErrInvalidGQLRequest
}
}
return r, nil
}
ctSplitParams := strings.Split(ctx.ContentType(), delimiterCTParams)
switch ctSplitParams[0] {
case jsonCTshort:
if err := ctx.UnJSON(&r); err != nil {
return nil, err
}
case gqlCT:
r.Query = string(ctx.PostBody())
}
return r, nil
} | go | {
"resource": ""
} |
q19679 | NewRequest | train | func (fw *firewall) NewRequest(ctx *Context) (shouldBeBlocked bool, remoteAddr string) {
if ctx == nil || ctx.RemoteAddr().String() == "0.0.0.0" {
return false, ""
}
// Get the remote addresse of the request
remoteAddr = ctx.RemoteIP().String()
// Check if this remote address is blocked
if fw.isBlocked(remoteAddr) {
return true, remoteAddr
}
// Register the new request in a new goroutine
go fw.addRequest(remoteAddr)
return false, remoteAddr
} | go | {
"resource": ""
} |
q19680 | isBlocked | train | func (fw *firewall) isBlocked(remoteAddr string) bool {
fw.blockListMutex.Lock()
// Check if the remote address exists in the blocked map
_, exists := fw.blockList[remoteAddr]
fw.blockListMutex.Unlock()
return exists
} | go | {
"resource": ""
} |
q19681 | Setup | train | func Setup(app *gramework.App) {
err := app.UseAfterRequest(serveXHost)
if err != nil {
app.Logger.WithError(err).WithField("package", "mw/xhostname").Error("could not register middleware")
}
} | go | {
"resource": ""
} |
q19682 | Encode | train | func Encode(providerName []byte, params string, salt []byte, key []byte) (res []byte) {
salt64 := encodeBase64(salt)
key64 := encodeBase64(key)
// final res len = len(providerName) + len(params) + len(salt) + len(key) + 4, because we need 4 dividers
res = append(res, Divider)
res = append(res, providerName...)
res = append(res, Divider)
res = append(res, params...)
res = append(res, Divider)
res = append(res, salt64...)
res = append(res, Divider)
res = append(res, key64...)
return res
} | go | {
"resource": ""
} |
q19683 | encodeBase64 | train | func encodeBase64(in []byte) (out []byte) {
enc := base64.StdEncoding
out = make([]byte, enc.EncodedLen(len(in)))
enc.Encode(out, in)
return out
} | go | {
"resource": ""
} |
q19684 | Decode | train | func Decode(mcf []byte, expectedPWType []byte) (providerName []byte, params string, salt []byte, key []byte, err error) {
if len(mcf) <= 1 || mcf[0] != Divider {
err = ErrorInvalidDecodeInput
return
}
parts := bytes.Split(mcf[1:], splitDivider)
if len(parts) != 4 {
err = ErrorInvalidDecodeInput
return
}
if subtle.ConstantTimeCompare(parts[0], expectedPWType) == 0 {
err = ErrorInvalidDecodeInput
return
}
params = string(parts[1])
saltDecoded, err := decodeBase64(parts[2])
if err != nil {
err = ErrorInvalidDecodeInput
return
}
salt = saltDecoded
keyDecoded, err := decodeBase64(parts[3])
if err != nil {
err = ErrorInvalidDecodeInput
return
}
key = keyDecoded
return
} | go | {
"resource": ""
} |
q19685 | GET | train | func (client *Instance) GET() (statusCode int, body []byte, err error) {
api, err := client.nextServer()
if err != nil {
return 0, nil, err
}
return api.HostClient.Get(nil, api.Addr)
} | go | {
"resource": ""
} |
q19686 | GetJSON | train | func (client *Instance) GetJSON(v interface{}) (statusCode int, err error) {
statusCode, body, err := client.GET()
if err != nil {
return 0, err
}
return statusCode, json.NewDecoder(bytes.NewReader(body)).Decode(&v)
} | go | {
"resource": ""
} |
q19687 | NewProvider | train | func NewProvider() Server {
return Server{
server: rpc.NewServer(),
rwc: rwCloser{os.Stdin, os.Stdout},
}
} | go | {
"resource": ""
} |
q19688 | Close | train | func (s Server) Close() error {
if s.codec != nil {
return s.codec.Close()
}
return s.rwc.Close()
} | go | {
"resource": ""
} |
q19689 | ServeCodec | train | func (s Server) ServeCodec(f func(io.ReadWriteCloser) rpc.ServerCodec) {
s.server.ServeCodec(f(s.rwc))
} | go | {
"resource": ""
} |
q19690 | StartProvider | train | func StartProvider(output io.Writer, path string, args ...string) (*rpc.Client, error) {
pipe, err := start(makeCommand(output, path, args))
if err != nil {
return nil, err
}
return rpc.NewClient(pipe), nil
} | go | {
"resource": ""
} |
q19691 | StartProviderCodec | train | func StartProviderCodec(
f func(io.ReadWriteCloser) rpc.ClientCodec,
output io.Writer,
path string,
args ...string,
) (*rpc.Client, error) {
pipe, err := start(makeCommand(output, path, args))
if err != nil {
return nil, err
}
return rpc.NewClientWithCodec(f(pipe)), nil
} | go | {
"resource": ""
} |
q19692 | StartConsumer | train | func StartConsumer(output io.Writer, path string, args ...string) (Server, error) {
pipe, err := start(makeCommand(output, path, args))
if err != nil {
return Server{}, err
}
return Server{
server: rpc.NewServer(),
rwc: pipe,
}, nil
} | go | {
"resource": ""
} |
q19693 | NewConsumer | train | func NewConsumer() *rpc.Client {
return rpc.NewClient(rwCloser{os.Stdin, os.Stdout})
} | go | {
"resource": ""
} |
q19694 | NewConsumerCodec | train | func NewConsumerCodec(f func(io.ReadWriteCloser) rpc.ClientCodec) *rpc.Client {
return rpc.NewClientWithCodec(f(rwCloser{os.Stdin, os.Stdout}))
} | go | {
"resource": ""
} |
q19695 | start | train | func start(cmd commander) (_ ioPipe, err error) {
in, err := cmd.StdinPipe()
if err != nil {
return ioPipe{}, err
}
defer func() {
if err != nil {
in.Close()
}
}()
out, err := cmd.StdoutPipe()
if err != nil {
return ioPipe{}, err
}
defer func() {
if err != nil {
out.Close()
}
}()
proc, err := cmd.Start()
if err != nil {
return ioPipe{}, err
}
return ioPipe{out, in, proc}, nil
} | go | {
"resource": ""
} |
q19696 | Close | train | func (iop ioPipe) Close() error {
err := iop.ReadCloser.Close()
if writeErr := iop.WriteCloser.Close(); writeErr != nil {
err = writeErr
}
if procErr := iop.closeProc(); procErr != nil {
err = procErr
}
return err
} | go | {
"resource": ""
} |
q19697 | closeProc | train | func (iop ioPipe) closeProc() error {
result := make(chan error, 1)
go func() { _, err := iop.proc.Wait(); result <- err }()
if err := iop.proc.Signal(os.Interrupt); err != nil {
return err
}
select {
case err := <-result:
return err
case <-time.After(procTimeout):
if err := iop.proc.Kill(); err != nil {
return fmt.Errorf("error killing process after timeout: %s", err)
}
return errProcStopTimeout
}
} | go | {
"resource": ""
} |
q19698 | Close | train | func (rw rwCloser) Close() error {
err := rw.ReadCloser.Close()
if err := rw.WriteCloser.Close(); err != nil {
return err
}
return err
} | go | {
"resource": ""
} |
q19699 | Name | train | func (f *Field) Name(recv string, unsafePkg Import) string {
if !f.Private() || !f.external {
return recv + "." + f.name
}
return `*(*` + f.typeStr() + `)(` + unsafePkg() + `.Pointer(` + recv + `.FieldByName("` + f.name + `").UnsafeAddr()))`
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.