_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30200 | OnRegister | train | func (k *Kite) OnRegister(handler func(*protocol.RegisterResult)) {
k.handlersMu.Lock()
k.onRegisterHandlers = append(k.onRegisterHandlers, handler)
k.handlersMu.Unlock()
} | go | {
"resource": ""
} |
q30201 | RSAKey | train | func (k *Kite) RSAKey(token *jwt.Token) (interface{}, error) {
k.verifyOnce.Do(k.verifyInit)
kontrolKey := k.KontrolKey()
if kontrolKey == nil {
panic("kontrol key is not set in config")
}
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, o... | go | {
"resource": ""
} |
q30202 | Error | train | func (err *ErrClose) Error() string {
if len(err.Errs) == 1 {
return err.Errs[0].Error()
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "The following kites failed to close:\n\n")
for i, e := range err.Errs {
if e == nil {
continue
}
fmt.Fprintf(&buf, "\t[%d] %s\n", i, e)
}
return buf.String()
} | go | {
"resource": ""
} |
q30203 | RunCleaner | train | func (p *Postgres) RunCleaner(interval, expire time.Duration) {
cleanFunc := func() {
affectedRows, err := p.CleanExpiredRows(expire)
if err != nil {
p.Log.Warning("postgres: cleaning old rows failed: %s", err)
} else if affectedRows != 0 {
p.Log.Debug("postgres: cleaned up %d rows", affectedRows)
}
}
... | go | {
"resource": ""
} |
q30204 | CleanExpiredRows | train | func (p *Postgres) CleanExpiredRows(expire time.Duration) (int64, error) {
// See: http://stackoverflow.com/questions/14465727/how-to-insert-things-like-now-interval-2-minutes-into-php-pdo-query
// basically by passing an integer to INTERVAL is not possible, we need to
// cast it. However there is a more simpler way... | go | {
"resource": ""
} |
q30205 | selectQuery | train | func selectQuery(query *protocol.KontrolQuery) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kites := psql.Select("*").From("kite.kite")
fields := query.Fields()
andQuery := sq.And{}
// we stop for the first empty value
for _, key := range keyOrder {
v := fields[key... | go | {
"resource": ""
} |
q30206 | insertKiteQuery | train | func insertKiteQuery(kiteProt *protocol.Kite, url, keyId string) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kiteValues := kiteProt.Values()
values := make([]interface{}, len(kiteValues))
for i, kiteVal := range kiteValues {
values[i] = kiteVal
}
values = append(... | go | {
"resource": ""
} |
q30207 | SetupSignalHandler | train | func (k *Kite) SetupSignalHandler() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGUSR2)
go func() {
for s := range c {
k.Log.Info("Got signal: %s", s)
if debugMode {
// toogle back to old settings.
k.Log.Info("Disabling debug mode")
if k.SetLogLevel == nil {
k.Log.Error("SetLo... | go | {
"resource": ""
} |
q30208 | DialXHR | train | func DialXHR(uri string, cfg *config.Config) (*XHRSession, error) {
// following /server_id/session_id should always be the same for every session
serverID := threeDigits()
sessionID := utils.RandomString(20)
sessionURL := uri + "/" + serverID + "/" + sessionID
// start the initial session handshake
sessionResp,... | go | {
"resource": ""
} |
q30209 | ServeKite | train | func (w *webRTCHandler) ServeKite(r *Request) (interface{}, error) {
var args protocol.WebRTCSignalMessage
if err := r.Args.One().Unmarshal(&args); err != nil {
return nil, fmt.Errorf("invalid query: %s", err)
}
args.Src = r.Client.ID
w.registerSrc(r.Client)
dst, err := w.getDst(args.Dst)
if err != nil {
... | go | {
"resource": ""
} |
q30210 | handleLog | train | func (k *Kite) handleLog(r *Request) (interface{}, error) {
msg, err := r.Args.One().String()
if err != nil {
return nil, err
}
k.Log.Info("%s: %s", r.Client.Name, msg)
return nil, nil
} | go | {
"resource": ""
} |
q30211 | handlePrint | train | func handlePrint(r *Request) (interface{}, error) {
return fmt.Print(r.Args.One().MustString())
} | go | {
"resource": ""
} |
q30212 | handlePrompt | train | func handlePrompt(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
var s string
_, err := fmt.Scanln(&s)
return s, err
} | go | {
"resource": ""
} |
q30213 | handleGetPass | train | func handleGetPass(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
data, err := terminal.ReadPassword(int(os.Stdin.Fd())) // stdin
fmt.Println()
if err != nil {
return nil, err
}
return string(data), nil
} | go | {
"resource": ""
} |
q30214 | handleNotifyDarwin | train | func handleNotifyDarwin(r *Request) (interface{}, error) {
args := r.Args.MustSliceOfLength(3)
cmd := exec.Command("osascript", "-e", fmt.Sprintf("display notification \"%s\" with title \"%s\" subtitle \"%s\"",
args[1].MustString(), args[2].MustString(), args[0].MustString()))
return nil, cmd.Start()
} | go | {
"resource": ""
} |
q30215 | handleTunnel | train | func handleTunnel(r *Request) (interface{}, error) {
var args struct {
URL string
}
r.Args.One().MustUnmarshal(&args)
parsed, err := url.Parse(args.URL)
if err != nil {
return nil, err
}
requestHeader := http.Header{}
requestHeader.Add("Origin", "http://"+parsed.Host)
remoteConn, _, err := websocket.Def... | go | {
"resource": ""
} |
q30216 | parse | train | func (t *TokenRenewer) parse(tokenString string) error {
claims := &kitekey.KiteClaims{}
_, err := jwt.ParseWithClaims(tokenString, claims, t.localKite.RSAKey)
if err != nil {
valErr, ok := err.(*jwt.ValidationError)
if !ok {
return err
}
// do noy return for ValidationErrorSignatureValid. This is becau... | go | {
"resource": ""
} |
q30217 | renewDuration | train | func (t *TokenRenewer) renewDuration() time.Duration {
return t.validUntil.Add(-renewBefore).Sub(time.Now().UTC())
} | go | {
"resource": ""
} |
q30218 | renewToken | train | func (t *TokenRenewer) renewToken() error {
renew := &protocol.Kite{
ID: t.client.Kite.ID,
}
token, err := t.localKite.GetToken(renew)
if err != nil {
return err
}
if err = t.parse(token); err != nil {
return err
}
t.client.authMu.Lock()
t.client.Auth.Key = token
t.client.authMu.Unlock()
t.client.c... | go | {
"resource": ""
} |
q30219 | NewFromKiteKey | train | func NewFromKiteKey(file string) (*Config, error) {
key, err := kitekey.ParseFile(file)
if err != nil {
return nil, err
}
var c Config
if err := c.ReadToken(key); err != nil {
return nil, err
}
return &c, nil
} | go | {
"resource": ""
} |
q30220 | ReadKiteKey | train | func (c *Config) ReadKiteKey() error {
key, err := kitekey.Parse()
if err != nil {
return err
}
return c.ReadToken(key)
} | go | {
"resource": ""
} |
q30221 | ReadToken | train | func (c *Config) ReadToken(key *jwt.Token) error {
c.KiteKey = key.Raw
claims, ok := key.Claims.(*kitekey.KiteClaims)
if !ok {
return errors.New("no claims found")
}
c.Username = claims.Subject
c.KontrolUser = claims.Issuer
c.Id = claims.Id // jti is used for jwt's but let's also use it for kite ID
c.Kontro... | go | {
"resource": ""
} |
q30222 | Copy | train | func (c *Config) Copy() *Config {
copy := *c
if c.XHR != nil {
xhr := *copy.XHR
copy.XHR = &xhr
}
if c.Client != nil {
client := *copy.Client
copy.Client = &client
}
if c.Websocket != nil {
ws := *copy.Websocket
copy.Websocket = &ws
}
return ©
} | go | {
"resource": ""
} |
q30223 | runMethod | train | func (c *Client) runMethod(method *Method, args *dnode.Partial) {
var (
callFunc func(interface{}, *Error)
request *Request
)
// Recover dnode argument errors and send them back. The caller can use
// functions like MustString(), MustSlice()... without the fear of panic.
defer func() {
if r := recover(); r... | go | {
"resource": ""
} |
q30224 | runCallback | train | func (c *Client) runCallback(callback func(*dnode.Partial), args *dnode.Partial) {
// Do not panic no matter what.
defer func() {
if err := recover(); err != nil {
c.LocalKite.Log.Warning("Error in calling the callback function : %v", err)
}
}()
// Call the callback function.
callback(args)
} | go | {
"resource": ""
} |
q30225 | authenticate | train | func (r *Request) authenticate() *Error {
// Trust the Kite if we have initiated the connection. Following casts
// means, session is opened by the client.
if _, ok := r.Client.session.(*sockjsclient.WebsocketSession); ok {
return nil
}
if _, ok := r.Client.session.(*sockjsclient.XHRSession); ok {
return nil... | go | {
"resource": ""
} |
q30226 | AuthenticateFromToken | train | func (k *Kite) AuthenticateFromToken(r *Request) error {
k.verifyOnce.Do(k.verifyInit)
token, err := jwt.ParseWithClaims(r.Auth.Key, &kitekey.KiteClaims{}, r.LocalKite.RSAKey)
if e, ok := err.(*jwt.ValidationError); ok {
// Translate public key mismatch errors to token-is-expired one.
// This is to signal remo... | go | {
"resource": ""
} |
q30227 | AuthenticateFromKiteKey | train | func (k *Kite) AuthenticateFromKiteKey(r *Request) error {
claims := &kitekey.KiteClaims{}
token, err := jwt.ParseWithClaims(r.Auth.Key, claims, k.verify)
if err != nil {
return err
}
if !token.Valid {
return errors.New("Invalid signature in kite key")
}
if claims.Subject == "" {
return errors.New("toke... | go | {
"resource": ""
} |
q30228 | publicIP | train | func publicIP() (net.IP, error) {
resp, err := http.Get(publicEcho)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// The ip address is 16 chars long, we read more
// to account for excessive whitespace.
p, err := ioutil.ReadAll(io.LimitReader(resp.Body, 24))
if err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q30229 | extractTar | train | func extractTar(r io.Reader, dir string) error {
first := true // true if we are on the first entry of tarball
tr := tar.NewReader(r)
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
return err
}
// Check if the same kite version is installed before
... | go | {
"resource": ""
} |
q30230 | validatePackage | train | func validatePackage(tempKitePath, repoName string) (bundlePath string, err error) {
dirs, err := ioutil.ReadDir(tempKitePath)
if err != nil {
return "", err
}
if len(dirs) != 1 {
return "", errors.New("Invalid package: Package must contain only one directory.")
}
bundlePath = filepath.Join(tempKitePath, di... | go | {
"resource": ""
} |
q30231 | RemoveCallback | train | func (s *Scrubber) RemoveCallback(id uint64) {
s.Lock()
delete(s.callbacks, id)
s.Unlock()
} | go | {
"resource": ""
} |
q30232 | addHandle | train | func (k *Kite) addHandle(method string, handler Handler) *Method {
authenticate := true
if k.Config.DisableAuthentication {
authenticate = false
}
m := &Method{
name: method,
handler: handler,
authenticate: authenticate,
handling: k.MethodHandling,
}
k.handlers[method] = m
return m
} | go | {
"resource": ""
} |
q30233 | PreHandle | train | func (m *Method) PreHandle(handler Handler) *Method {
m.preHandlers = append(m.preHandlers, handler)
return m
} | go | {
"resource": ""
} |
q30234 | PostHandle | train | func (m *Method) PostHandle(handler Handler) *Method {
m.postHandlers = append(m.postHandlers, handler)
return m
} | go | {
"resource": ""
} |
q30235 | FinalFunc | train | func (m *Method) FinalFunc(f FinalFunc) *Method {
m.finalFuncs = append(m.finalFuncs, f)
return m
} | go | {
"resource": ""
} |
q30236 | Handle | train | func (k *Kite) Handle(method string, handler Handler) *Method {
return k.addHandle(method, handler)
} | go | {
"resource": ""
} |
q30237 | PreHandle | train | func (k *Kite) PreHandle(handler Handler) {
k.preHandlers = append(k.preHandlers, handler)
} | go | {
"resource": ""
} |
q30238 | PostHandle | train | func (k *Kite) PostHandle(handler Handler) {
k.postHandlers = append(k.postHandlers, handler)
} | go | {
"resource": ""
} |
q30239 | FinalFunc | train | func (k *Kite) FinalFunc(f FinalFunc) {
k.finalFuncs = append(k.finalFuncs, f)
} | go | {
"resource": ""
} |
q30240 | Matches | train | func (p Path) Matches(other string) bool {
if CaseSensitivePath {
return strings.HasPrefix(string(p), other)
}
return strings.HasPrefix(strings.ToLower(string(p)), strings.ToLower(other))
} | go | {
"resource": ""
} |
q30241 | Write | train | func (w *gzipResponseWriter) Write(b []byte) (int, error) {
if w.Header().Get("Content-Type") == "" {
w.Header().Set("Content-Type", http.DetectContentType(b))
}
if !w.statusCodeWritten {
w.WriteHeader(http.StatusOK)
}
n, err := w.Writer.Write(b)
return n, err
} | go | {
"resource": ""
} |
q30242 | IsHidden | train | func (fs FileServer) IsHidden(d os.FileInfo) bool {
// If the file is supposed to be hidden, return a 404
for _, hiddenPath := range fs.Hide {
// Check if the served file is exactly the hidden file.
if hFile, err := fs.Root.Open(hiddenPath); err == nil {
fs, _ := hFile.Stat()
hFile.Close()
if os.SameFile... | go | {
"resource": ""
} |
q30243 | Redirect | train | func Redirect(w http.ResponseWriter, r *http.Request, newPath string, statusCode int) {
if q := r.URL.RawQuery; q != "" {
newPath += "?" + q
}
http.Redirect(w, r, newPath, statusCode)
} | go | {
"resource": ""
} |
q30244 | TapperFromContext | train | func TapperFromContext(ctx context.Context) (t Tapper) {
t, _ = ctx.(Tapper)
return
} | go | {
"resource": ""
} |
q30245 | TapBuilder | train | func (h Dnstap) TapBuilder() msg.Builder {
return msg.Builder{Full: h.Pack}
} | go | {
"resource": ""
} |
q30246 | GetIssues | train | func (dp *DHCPPool) GetIssues(macs []string) ([]string, map[uint64]string) {
dp.lock.Lock()
defer dp.lock.Unlock()
var found bool
found = false
var inPoolNotInCache []string
var duplicateInPool map[uint64]string
duplicateInPool = make(map[uint64]string)
var count int
var saveindex uint64
for i := uint64(0); ... | go | {
"resource": ""
} |
q30247 | ReserveIPIndex | train | func (dp *DHCPPool) ReserveIPIndex(index uint64, mac string) (error, string) {
dp.lock.Lock()
defer dp.lock.Unlock()
if index >= dp.capacity {
return errors.New("Trying to reserve an IP that is outside the capacity of this pool"), FreeMac
}
if _, free := dp.free[index]; free {
delete(dp.free, index)
dp.mac... | go | {
"resource": ""
} |
q30248 | FreeIPIndex | train | func (dp *DHCPPool) FreeIPIndex(index uint64) error {
dp.lock.Lock()
defer dp.lock.Unlock()
if !dp.IndexInPool(index) {
return errors.New("Trying to free an IP that is outside the capacity of this pool")
}
if _, free := dp.free[index]; free {
return errors.New("IP is already free")
} else {
dp.free[index]... | go | {
"resource": ""
} |
q30249 | GetFreeIPIndex | train | func (dp *DHCPPool) GetFreeIPIndex(mac string) (uint64, string, error) {
dp.lock.Lock()
defer dp.lock.Unlock()
if len(dp.free) == 0 {
return 0, FreeMac, errors.New("DHCP pool is full")
}
index := rand.Intn(len(dp.free))
var available uint64
for available = range dp.free {
if index == 0 {
break
}
ind... | go | {
"resource": ""
} |
q30250 | FreeIPsRemaining | train | func (dp *DHCPPool) FreeIPsRemaining() uint64 {
dp.lock.Lock()
defer dp.lock.Unlock()
return uint64(len(dp.free))
} | go | {
"resource": ""
} |
q30251 | Stop | train | func (fw *WatchGuard) Stop(ctx context.Context, info map[string]string) (bool, error) {
p := fw.stopRadiusPacket(ctx, info)
client := fw.getRadiusClient(ctx)
var err error
client.Dialer.LocalAddr, err = net.ResolveUDPAddr("udp", fw.getSourceIp(ctx).String()+":0")
sharedutils.CheckError(err)
// Use the backgroun... | go | {
"resource": ""
} |
q30252 | stopRadiusPacket | train | func (fw *WatchGuard) stopRadiusPacket(ctx context.Context, info map[string]string) *radius.Packet {
r := radius.New(radius.CodeAccountingRequest, []byte(fw.Password))
rfc2866.AcctSessionID_AddString(r, "acct_pf-"+info["mac"])
rfc2866.AcctStatusType_Add(r, rfc2866.AcctStatusType_Value_Stop)
rfc2865.UserName_AddStri... | go | {
"resource": ""
} |
q30253 | setup | train | func setup(c *caddy.Controller) error {
var max int
for c.Next() {
val := c.Val()
switch val {
case "requestlimit":
if !c.NextArg() {
fmt.Println("Missing limit argument for requestlimit")
return c.ArgErr()
} else {
val := c.Val()
if val != "" {
max64, err := strconv.ParseInt(c.Val()... | go | {
"resource": ""
} |
q30254 | ServeHTTP | train | func (h RequestLimitHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
// Limit the concurrent requests that can run through the sem channel
h.sem <- 1
defer func() {
<-h.sem
}()
return h.Next.ServeHTTP(w, r)
} | go | {
"resource": ""
} |
q30255 | NewContext | train | func NewContext(ctx context.Context) context.Context {
u, _ := uuid.NewV4()
uStr := u.String()
ctx = context.WithValue(ctx, requestUuidKey, uStr)
ctx = context.WithValue(ctx, processPidKey, strconv.Itoa(os.Getpid()))
ctx = context.WithValue(ctx, additionnalLogElementsKey, make(map[interface{}]interface{}))
return... | go | {
"resource": ""
} |
q30256 | dualStream | train | func dualStream(w1 io.Writer, r1 io.Reader, w2 io.Writer, r2 io.Reader) error {
errChan := make(chan error)
stream := func(w io.Writer, r io.Reader) {
buf := bufferPool.Get().([]byte)
buf = buf[0:cap(buf)]
_, _err := flushingIoCopy(w, r, buf)
errChan <- _err
}
go stream(w1, r1)
go stream(w2, r2)
err1 :=... | go | {
"resource": ""
} |
q30257 | serveHijack | train | func serveHijack(w http.ResponseWriter, targetConn net.Conn) (int, error) {
hijacker, ok := w.(http.Hijacker)
if !ok {
return http.StatusInternalServerError, errors.New("ResponseWriter does not implement Hijacker")
}
clientConn, bufReader, err := hijacker.Hijack()
if err != nil {
return http.StatusInternalServ... | go | {
"resource": ""
} |
q30258 | checkCredentials | train | func (fp *ForwardProxy) checkCredentials(r *http.Request) error {
pa := strings.Split(r.Header.Get("Proxy-Authorization"), " ")
if len(pa) != 2 {
return errors.New("Proxy-Authorization is required! Expected format: <type> <credentials>")
}
if strings.ToLower(pa[0]) != "basic" {
return errors.New("Auth type is n... | go | {
"resource": ""
} |
q30259 | isSubdomain | train | func isSubdomain(s, domain string) bool {
if s == domain {
return true
}
if strings.HasSuffix(s, "."+domain) {
return true
}
return false
} | go | {
"resource": ""
} |
q30260 | forwardResponse | train | func forwardResponse(w http.ResponseWriter, response *http.Response) error {
w.Header().Del("Server") // remove Server: Caddy, append via instead
w.Header().Add("Via", strconv.Itoa(response.ProtoMajor)+"."+strconv.Itoa(response.ProtoMinor)+" caddy")
for header, values := range response.Header {
for _, val := rang... | go | {
"resource": ""
} |
q30261 | generateForwardRequest | train | func (fp *ForwardProxy) generateForwardRequest(inReq *http.Request) (*http.Request, error) {
// Scheme has to be appended to avoid `unsupported protocol scheme ""` error.
// `http://` is used, since this initial request itself is always HTTP, regardless of what client and server
// may speak afterwards.
if len(inRe... | go | {
"resource": ""
} |
q30262 | createUpstreamRequest | train | func createUpstreamRequest(r *http.Request) *http.Request {
outreq := new(http.Request)
*outreq = *r // includes shallow copies of maps, but okay
// We should set body to nil explicitly if request body is empty.
// For server requests the Request Body is always non-nil.
if r.ContentLength == 0 {
outreq.Body = ni... | go | {
"resource": ""
} |
q30263 | StartupHooks | train | func StartupHooks(serverType string) error {
for stype, stypePlugins := range plugins {
if stype != "" && stype != serverType {
continue
}
for name := range stypePlugins {
if stypePlugins[name].StartupHook == nil {
continue
}
err := stypePlugins[name].StartupHook()
if err != nil {
return... | go | {
"resource": ""
} |
q30264 | BreadcrumbMap | train | func (l Listing) BreadcrumbMap() map[string]string {
result := map[string]string{}
if len(l.Path) == 0 {
return result
}
// skip trailing slash
lpath := l.Path
if lpath[len(lpath)-1] == '/' {
lpath = lpath[:len(lpath)-1]
}
parts := strings.Split(lpath, "/")
for i, part := range parts {
if i == 0 && pa... | go | {
"resource": ""
} |
q30265 | applySort | train | func (l Listing) applySort() {
// Check '.Order' to know how to sort
if l.Order == "desc" {
switch l.Sort {
case sortByName:
sort.Sort(sort.Reverse(byName(l)))
case sortBySize:
sort.Sort(sort.Reverse(bySize(l)))
case sortByTime:
sort.Sort(sort.Reverse(byTime(l)))
default:
// If not one of the ab... | go | {
"resource": ""
} |
q30266 | ServeHTTP | train | func (b Browse) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
// See if there's a browse configuration to match the path
var bc *Config
for i := range b.Configs {
if httpserver.Path(r.URL.Path).Matches(b.Configs[i].PathScope) {
bc = &b.Configs[i]
break
}
}
if bc == nil {
return b.Nex... | go | {
"resource": ""
} |
q30267 | executeShutdownCallbacks | train | func executeShutdownCallbacks(signame string) (exitCode int) {
shutdownCallbacksOnce.Do(func() {
errs := allShutdownCallbacks()
if len(errs) > 0 {
for _, err := range errs {
log.Printf("[ERROR] %s shutdown: %v", signame, err)
}
exitCode = 1
}
})
return
} | go | {
"resource": ""
} |
q30268 | standardizeAddress | train | func standardizeAddress(str string) (Address, error) {
input := str
// Split input into components (prepend with // to assert host by default)
if !strings.Contains(str, "//") && !strings.HasPrefix(str, "/") {
str = "//" + str
}
u, err := url.Parse(str)
if err != nil {
return Address{}, err
}
// separate h... | go | {
"resource": ""
} |
q30269 | Close | train | func (l *Logger) Close() error {
// Will close local/remote syslog connections too :)
if closer, ok := l.writer.(io.WriteCloser); ok {
l.fileMu.Lock()
err := closer.Close()
l.fileMu.Unlock()
return err
}
return nil
} | go | {
"resource": ""
} |
q30270 | Transport | train | func Transport(s string) string {
switch {
case strings.HasPrefix(s, TransportTLS+"://"):
return TransportTLS
case strings.HasPrefix(s, TransportDNS+"://"):
return TransportDNS
case strings.HasPrefix(s, TransportGRPC+"://"):
return TransportGRPC
}
return TransportDNS
} | go | {
"resource": ""
} |
q30271 | normalizeZone | train | func normalizeZone(str string) (zoneAddr, error) {
var err error
// Default to DNS if there isn't a transport protocol prefix.
trans := TransportDNS
switch {
case strings.HasPrefix(str, TransportTLS+"://"):
trans = TransportTLS
str = str[len(TransportTLS+"://"):]
case strings.HasPrefix(str, TransportDNS+":/... | go | {
"resource": ""
} |
q30272 | cloneTLSClientConfig | train | func cloneTLSClientConfig(cfg *tls.Config) *tls.Config {
if cfg == nil {
return &tls.Config{}
}
return &tls.Config{
Rand: cfg.Rand,
Time: cfg.Time,
Certificates: cfg.Certificates,
NameToCertificate: cfg.NameToCertificate,
GetCertifica... | go | {
"resource": ""
} |
q30273 | matches | train | func matches(re *regexp.Regexp, filename, template string) (match bool, origin string) {
base := path.Base(filename)
matches := re.FindStringSubmatchIndex(base)
if matches == nil {
return false, ""
}
by := re.ExpandString(nil, template, base, matches)
if by == nil {
return false, ""
}
origin = dns.Fqdn(s... | go | {
"resource": ""
} |
q30274 | Accept | train | func (gl *gracefulListener) Accept() (c net.Conn, err error) {
c, err = gl.Listener.Accept()
if err != nil {
return
}
c = gracefulConn{Conn: c, connWg: gl.connWg}
gl.connWg.Add(1)
return
} | go | {
"resource": ""
} |
q30275 | Close | train | func (gl *gracefulListener) Close() error {
gl.Lock()
if gl.stopped {
gl.Unlock()
return syscall.EINVAL
}
gl.Unlock()
gl.stop <- nil
return <-gl.stop
} | go | {
"resource": ""
} |
q30276 | Close | train | func (c gracefulConn) Close() error {
err := c.Conn.Close()
if err != nil {
return err
}
// close can fail on http2 connections (as of Oct. 2015, before http2 in std lib)
// so don't decrement count unless close succeeds
c.connWg.Done()
return nil
} | go | {
"resource": ""
} |
q30277 | OnRestart | train | func (c *Controller) OnRestart(fn func() error) {
c.instance.onRestart = append(c.instance.onRestart, fn)
} | go | {
"resource": ""
} |
q30278 | OnFinalShutdown | train | func (c *Controller) OnFinalShutdown(fn func() error) {
c.instance.onFinalShutdown = append(c.instance.onFinalShutdown, fn)
} | go | {
"resource": ""
} |
q30279 | parse | train | func (h *Hostsfile) parse(r io.Reader, override *hostsMap) *hostsMap {
hmap := newHostsMap()
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Bytes()
if i := bytes.Index(line, []byte{'#'}); i >= 0 {
// Discard comments.
line = line[0:i]
}
f := bytes.Fields(line)
if len(f) < 2 {
... | go | {
"resource": ""
} |
q30280 | LookupStaticAddr | train | func (h *Hostsfile) LookupStaticAddr(addr string) []string {
h.RLock()
defer h.RUnlock()
addr = parseLiteralIP(addr).String()
if addr == "" {
return nil
}
if len(h.hmap.byAddr) != 0 {
if hosts, ok := h.hmap.byAddr[addr]; ok {
hostsCp := make([]string, len(hosts))
copy(hostsCp, hosts)
return hostsCp
... | go | {
"resource": ""
} |
q30281 | key | train | func key(m *dns.Msg, t response.Type, do bool) int {
// We don't store truncated responses.
if m.Truncated {
return -1
}
// Nor errors or Meta or Update
if t == response.OtherError || t == response.Meta || t == response.Update {
return -1
}
return int(hash(m.Question[0].Name, m.Question[0].Qtype, do))
} | go | {
"resource": ""
} |
q30282 | registerCallback | train | func registerCallback(c *caddy.Controller, registerFunc func(func() error)) error {
var funcs []func() error
for c.Next() {
args := c.RemainingArgs()
if len(args) == 0 {
return c.ArgErr()
}
nonblock := false
if len(args) > 1 && args[len(args)-1] == "&" {
// Run command in background; non-blocking
... | go | {
"resource": ""
} |
q30283 | AddrMsg | train | func (b *Builder) AddrMsg(a net.Addr, m *dns.Msg) (err error) {
err = b.RemoteAddr(a)
if err != nil {
return
}
return b.Msg(m)
} | go | {
"resource": ""
} |
q30284 | Msg | train | func (b *Builder) Msg(m *dns.Msg) (err error) {
if b.Full {
err = b.Pack(m)
}
return
} | go | {
"resource": ""
} |
q30285 | HostPort | train | func (d *Data) HostPort(addr string) error {
ip, port, err := net.SplitHostPort(addr)
if err != nil {
return err
}
p, err := strconv.ParseUint(port, 10, 32)
if err != nil {
return err
}
d.Port = uint32(p)
if ip := net.ParseIP(ip); ip != nil {
d.Address = []byte(ip)
if ip := ip.To4(); ip != nil {
d.S... | go | {
"resource": ""
} |
q30286 | RemoteAddr | train | func (d *Data) RemoteAddr(remote net.Addr) error {
switch addr := remote.(type) {
case *net.TCPAddr:
d.Address = addr.IP
d.Port = uint32(addr.Port)
d.SocketProto = tap.SocketProtocol_TCP
case *net.UDPAddr:
d.Address = addr.IP
d.Port = uint32(addr.Port)
d.SocketProto = tap.SocketProtocol_UDP
default:
r... | go | {
"resource": ""
} |
q30287 | Pack | train | func (d *Data) Pack(m *dns.Msg) error {
packed, err := m.Pack()
if err != nil {
return err
}
d.Packed = packed
return nil
} | go | {
"resource": ""
} |
q30288 | newUpstream | train | func newUpstream(hosts []string, old *staticUpstream) Upstream {
upstream := &staticUpstream{
from: old.from,
HealthCheck: healthcheck.HealthCheck{
FailTimeout: 5 * time.Second,
MaxFails: 3,
},
ex: old.ex,
IgnoredSubDomains: old.IgnoredSubDomains,
}
upstream.Hosts = make([]*healthc... | go | {
"resource": ""
} |
q30289 | replaceEnvReferences | train | func replaceEnvReferences(s, refStart, refEnd string) string {
index := strings.Index(s, refStart)
for index != -1 {
endIndex := strings.Index(s, refEnd)
if endIndex != -1 {
ref := s[index : endIndex+len(refEnd)]
s = strings.Replace(s, ref, os.Getenv(ref[len(refStart):len(ref)-len(refEnd)]), -1)
} else {
... | go | {
"resource": ""
} |
q30290 | redirPlaintextHost | train | func redirPlaintextHost(cfg *SiteConfig) *SiteConfig {
redirPort := cfg.Addr.Port
if redirPort == "443" {
// default port is redundant
redirPort = ""
}
redirMiddleware := func(next Handler) Handler {
return HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
toURL := "https://" + r.Host... | go | {
"resource": ""
} |
q30291 | Report | train | func Report(req request.Request, zone, rcode string, size int, start time.Time) {
// Proto and Family.
net := req.Proto()
fam := "1"
if req.Family() == 2 {
fam = "2"
}
typ := req.QType()
RequestCount.WithLabelValues(zone, net, fam).Inc()
RequestDuration.WithLabelValues(zone).Observe(float64(time.Since(start... | go | {
"resource": ""
} |
q30292 | setup | train | func setup(c *caddy.Controller) error {
ctx := log.LoggerNewContext(context.Background())
apiAAA, err := buildApiAAAHandler(ctx)
if err != nil {
return err
}
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
apiAAA.Next = next
return apiAAA
})
return nil
} | go | {
"resource": ""
} |
q30293 | buildApiAAAHandler | train | func buildApiAAAHandler(ctx context.Context) (ApiAAAHandler, error) {
apiAAA := ApiAAAHandler{}
pfconfigdriver.PfconfigPool.AddStruct(ctx, &pfconfigdriver.Config.PfConf.Webservices)
pfconfigdriver.PfconfigPool.AddStruct(ctx, &pfconfigdriver.Config.UnifiedApiSystemUser)
pfconfigdriver.PfconfigPool.AddStruct(ctx, &... | go | {
"resource": ""
} |
q30294 | handleLogin | train | func (h ApiAAAHandler) handleLogin(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
ctx := r.Context()
defer statsd.NewStatsDTiming(ctx).Send("api-aaa.login")
var loginParams struct {
Username string
Password string
}
err := json.NewDecoder(r.Body).Decode(&loginParams)
if err != nil {
msg :... | go | {
"resource": ""
} |
q30295 | handleTokenInfo | train | func (h ApiAAAHandler) handleTokenInfo(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
ctx := r.Context()
defer statsd.NewStatsDTiming(ctx).Send("api-aaa.token_info")
info, expiration := h.authorization.GetTokenInfoFromBearerRequest(ctx, r)
if info != nil {
// We'll want to render the roles as an... | go | {
"resource": ""
} |
q30296 | NewServergRPC | train | func NewServergRPC(addr string, group []*Config) (*ServergRPC, error) {
s, err := NewServer(addr, group)
if err != nil {
return nil, err
}
gs := &ServergRPC{Server: s}
return gs, nil
} | go | {
"resource": ""
} |
q30297 | Query | train | func (s *ServergRPC) Query(ctx context.Context, in *pb.DnsPacket) (*pb.DnsPacket, error) {
msg := new(dns.Msg)
err := msg.Unpack(in.Msg)
if err != nil {
return nil, err
}
p, ok := peer.FromContext(ctx)
if !ok {
return nil, errors.New("no peer in gRPC context")
}
a, ok := p.Addr.(*net.TCPAddr)
if !ok {
... | go | {
"resource": ""
} |
q30298 | DefaultErrorFunc | train | func DefaultErrorFunc(w dns.ResponseWriter, r *dns.Msg, rc int) {
state := request.Request{W: w, Req: r}
answer := new(dns.Msg)
answer.SetRcode(r, rc)
state.SizeAndDo(answer)
vars.Report(state, vars.Dropped, rcode.ToString(rc), answer.Len(), time.Now())
w.WriteMsg(answer)
} | go | {
"resource": ""
} |
q30299 | Reload | train | func (z *Zone) Reload() error {
if z.NoReload {
return nil
}
tick := time.NewTicker(TickTime)
go func() {
for {
select {
case <-tick.C:
reader, err := os.Open(z.file)
if err != nil {
log.Printf("[ERROR] Failed to open zone %q in %q: %v", z.origin, z.file, err)
continue
}
ser... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.