_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([]... | 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... | 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 serv... | 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.Bu... | 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 ... | 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.Lev... | 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.interna... | 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 x... | 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().Ho... | 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... | 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),
},
MethodDELET... | 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(),
}).Err... | 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) [... | 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)
... | 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: generateIndexPag... | 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: generateI... | 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... | 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.mid... | 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
}
}
}
re... | 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.Sprin... | 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:
... | 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!", p... | 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!",... | 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.Operatio... | 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(remoteA... | 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...)
re... | 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
}
... | 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... | 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 {
... | 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.