id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11300 | := fe.rtmCollect
fe.mu.Unlock()
if rtmCollect == nil {
return
}
rtmCollect.AppendFeRTMTo(aggregate)
} | |
c11301 |
// First, add endpoints, that should be added and are not in lb
for newBeSrvURLKey, newBeSrv := range newServers {
if _, ok := oldServers[newBeSrvURLKey]; !ok {
if err := balancer.UpsertServer(newBeSrv.URL()); err != nil {
log.Errorf("Failed to add %v, err: %s", newBeSrv.URL(), err)
}
watcher.UpsertS... | |
c11302 |
active: make(map[string]int64),
idle: make(map[string]int64),
}
} | |
c11303 | http.StateIdle || cur == http.StateActive {
c.inc(conn, cur, 1)
}
if cur != http.StateNew {
c.inc(conn, prev, -1)
}
} | |
c11304 | http.StateActive: c.copy(c.active),
http.StateIdle: c.copy(c.idle),
}
} | |
c11305 | stapler,
connTck: connTck,
autoCertCache: autoCertCache,
serveWg: wg,
scopedRouter: scopedRouter,
state: srvStateInit,
}, nil
} | |
c11306 | Listener: lsn,
StateHandler: s.connTck.RegisterStateChange,
})
s.state = srvStateActive
s.serveWg.Add(1)
go s.serve(s.srv)
return nil
case srvStateHijacked:
s.state = srvStateActive
s.serveWg.Add(1)
go s.serve(s.srv)
return nil
}
return errors.Errorf("%v Calling start in unsupported stat... | |
c11307 | := s.reloadTLSCfg(hostCfgs); err != nil {
log.Errorf("Failed to reload TLS config: %v", err)
}
} | |
c11308 | "Error parsing Autocert Key block of type %s, for Host %s, as an ECDSA Private Key.", block.Type, hostCfg.Name)
}
autoCertMgr.Client.Key = ecPrivateKey
} else {
return nil, fmt.Errorf("AutoCert Private Key for Host %s is of unrecognized type: %s. Supported types"+
"are RSA PRIVATE KEY and EC PRIVAT... | |
c11309 | != nil {
return tls.Certificate{}, err
}
return cert, nil
} | |
c11310 | nil
} else if strings.HasPrefix(arg, "-vulcan") || strings.HasPrefix(arg, "--vulcan") {
// This argument should not be the last one
if i > len(args)-2 {
return "", nil, fmt.Errorf("provide a valid vulcan URL")
}
return args[i+1], cut(i, i+2, args), nil
}
}
return "http://localhost:8182", args, ni... | |
c11311 | listener,
stateHandler: o.StateHandler,
shutdown: make(chan bool),
shutdownFinished: make(chan bool, 1),
wg: new(sync.WaitGroup),
connToProps: make(map[net.Conn]connProperties),
}
} | |
c11312 | != nil {
return nil, err
}
return &Trace{
ReqHeaders: reqHeaders,
RespHeaders: respHeaders,
Addr: addr,
}, nil
} | |
c11313 | return newTraceHandler(next, t)
} | |
c11314 | reqHeaders=%v, respHeaders=%v", t.Addr, t.ReqHeaders, t.RespHeaders)
} | |
c11315 | New(t.Addr, t.ReqHeaders, t.RespHeaders)
} | |
c11316 | c.StringSlice("reqHeader"), c.StringSlice("respHeader"))
} | |
c11317 | Value: &cli.StringSlice{},
},
cli.StringSliceFlag{
Name: "respHeader",
Usage: "if provided, captures headers from response",
Value: &cli.StringSlice{},
},
}
} | |
c11318 | *stapler) {
s.clock = clock
}
} | |
c11319 | Timeout: 10 * time.Second,
KeepAlive: 5 * time.Second,
}).Dial,
TLSHandshakeTimeout: 5 * time.Second,
},
},
}
for _, o := range opts {
o(s)
}
if s.clock == nil {
s.clock = &timetools.RealTime{}
}
go s.fanOut()
return s
} | |
c11320 | nil {
panic(errors.Wrap(err, "must never fail"))
}
return cfg
} | |
c11321 | beSrvRTMs: make(map[backend.SrvURLKey]BeSrvEntry),
clock: &timetools.RealTime{},
handler: handler,
}, nil
} | |
c11322 | {
c.mu.Lock()
defer c.mu.Unlock()
return engine.NewRoundTripStats(c.rtm)
} | |
c11323 | c.mu.Unlock()
c.beSrvRTMs[beSrv.URLKey()] = BeSrvEntry{beSrv.Cfg(), NewRTMetrics()}
} | |
c11324 | defer c.mu.Unlock()
delete(c.beSrvRTMs, beSrvURLKey)
} | |
c11325 |
defer c.mu.Unlock()
return aggregate.Append(c.rtm)
} | |
c11326 | {
return fromSpec(c, next)
} | |
c11327 | RecoveryDuration: recoveryDuration,
FallbackDuration: fallbackDuration,
CheckPeriod: checkPeriod,
}
if _, err := fromSpec(spec, nil); err != nil {
return nil, err
}
return spec, nil
} | |
c11328 | c.Fallback, c.OnTripped, c.OnStandby, c.FallbackDuration, c.RecoveryDuration, c.CheckPeriod)
} | |
c11329 | c.Duration("fallbackDuration"), c.Duration("recoveryDuration"), c.Duration("checkPeriod"))
} | |
c11330 | css[i] = cs
}
}
var cache tls.ClientSessionCache
if !s.SessionTicketsDisabled {
cache, err = NewTLSSessionCache(&s.SessionCache)
if err != nil {
return nil, err
}
}
return &tls.Config{
MinVersion: min,
MaxVersion: max,
SessionTicketsDisabled: s.SessionTicketsDisabled,
ClientSessionCache: ... | |
c11331 | s.Type)
}
var capacity int
if params := s.Settings; params != nil {
if params.Capacity < 0 {
return nil, fmt.Errorf("bad LRU capacity: %v", params.Capacity)
} else if params.Capacity == 0 {
capacity = DefaultLRUCapacity
} else {
capacity = params.Capacity
}
}
return tls.NewLRUClientSessionCache(c... | |
c11332 | n.parseBackendChange,
n.parseFrontendMiddlewareChange,
n.parseFrontendChange,
n.parseHostChange,
n.parseListenerChange,
}
for _, matcher := range matchers {
a, err := matcher(response)
if a != nil || err != nil {
return a, err
}
}
return nil, nil
} | |
c11333 |
}
return &Backend{
Id: id,
Type: HTTP,
Settings: s,
}, nil
} | |
c11334 |
return (float64(e.Counters.NetErrors) / float64(e.Counters.Total))
} | |
c11335 | ServerError, http.StatusInternalServerError+1, 200, 300)
} | |
c11336 | s.id,
URL: s.rawURL,
}
} | |
c11337 | {
return SrvURLKey{scheme: u.Scheme, host: u.Host}
} | |
c11338 |
return Srv{}, errors.Wrapf(err, "bad url %v", beSrvCfg.URL)
}
return Srv{
id: beSrvCfg.Id,
rawURL: beSrvCfg.URL,
parsedURL: parsedURL,
}, nil
} | |
c11339 | &T{
id: beCfg.Id,
httpCfg: beCfg.HTTPSettings(),
httpTp: newTransport(tpCfg),
srvs: beSrvs,
}, nil
} | |
c11340 | {
return engine.BackendKey{Id: be.id}
} | |
c11341 |
if err != nil {
return false, errors.Wrap(err, "bad config")
}
// FIXME: But what about active connections?
be.httpTp.CloseIdleConnections()
be.httpCfg = beCfg.HTTPSettings()
httpTp := newTransport(tpCfg)
be.httpTp = httpTp
return true, nil
} | |
c11342 |
}
if i := be.indexOfServer(beSrvCfg.Id); i != -1 {
if be.srvs[i].URLKey() == beSrv.URLKey() {
return false, nil
}
be.cloneSrvCfgsIfSeen()
be.srvs[i] = beSrv
return true, nil
}
be.cloneSrvCfgsIfSeen()
be.srvs = append(be.srvs, beSrv)
return true, nil
} | |
c11343 | lastIdx := len(be.srvs) - 1
copy(be.srvs[i:], be.srvs[i+1:])
be.srvs[lastIdx] = Srv{}
be.srvs = be.srvs[:lastIdx]
return true
} | |
c11344 |
be.srvCfgsSeen = true
return be.httpTp, be.srvs
} | |
c11345 | == -1 {
return Srv{}, false
}
return be.srvs[i], true
} | |
c11346 | (proxy.Proxy, error) {
return mux.New(id, st, o)
} | |
c11347 | &sync.RWMutex{},
open: true,
}
} | |
c11348 | err = fmt.Errorf("listener already closed: err=(%s)", err)
}
return nil, err
}
return conn, nil
} | |
c11349 | }
l.open = false
return l.listener.Close()
} | |
c11350 | net.Listener {
l := new(TLSListener)
l.Listener = inner
l.config = config
return l
} | |
c11351 | var hook *logrus_syslog.SyslogHook
hook, err = logrus_syslog.NewSyslogHook("udp", "127.0.0.1:514", syslog.LOG_INFO|syslog.LOG_MAIL, "vulcand")
if err == nil {
log.SetOutput(devNull)
log.SetFormatter(&log.TextFormatter{DisableColors: true})
log.AddHook(hook)
return
}
}
}
if s.options.Log ==... | |
c11352 | files[i] = &proxy.FileDescriptor{
File: os.NewFile(uintptr(o.FileFD), o.FileName),
Address: o.Address,
}
}
return files, nil
} | |
c11353 | Address of (-37.813611,144.963056) is Melbourne's GPO, Postal Lane, Chinatown, Melbourne, City of Melbourne, Greater Melbourne, Victoria, 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"Melbourne's GPO, Postal Lane, Chinatown, Melbourne, City of Melbourne, Greater Melbourne,
// Victoria, 3000, A... | |
c11354 |
if z > minZoom && z <= maxZoom {
zoom = z
} else {
zoom = defaultZoom
}
return geo.HTTPGeocoder{
EndpointBuilder: baseURL(url),
ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | |
c11355 | geo.Geocoder {
return dataGeocoder{
AddressToLocation: addressToLocation,
LocationToAddress: LocationToAddress,
}
} | |
c11356 | cachedGeocoder{Geocoder: geocoder, Cache: cache}
} | |
c11357 | ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | |
c11358 | ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | |
c11359 | := strings.Trim(string(data), " []")
if body == "" {
return nil
}
if err := json.Unmarshal([]byte(body), obj); err != nil {
Logger.Printf("payload: %s\n", body)
return err
}
return nil
} | |
c11360 | := strconv.ParseFloat(value, 64)
return f
} | |
c11361 | code
return geo.HTTPGeocoder{
EndpointBuilder: baseURL{
getGeocodeURL(p, baseURLs...),
getReverseGeocodeURL(p, baseURLs...)},
ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | |
c11362 | if a.Village != "" {
locality = a.Village
}
return locality
} | |
c11363 | != "" {
street = a.Cycleway
} else if a.Footway != "" {
street = a.Footway
} else if a.Highway != "" {
street = a.Highway
}
return street
} | |
c11364 | err := opt(t); err != nil {
return err
}
}
return nil
} | |
c11365 |
t.fd = -1
return err
} | |
c11366 | }
termios.Cfmakecbreak((*syscall.Termios)(&a))
return termios.Tcsetattr(uintptr(t.fd), termios.TCSANOW, (*syscall.Termios)(&a))
} | |
c11367 | }
termios.Cfmakeraw((*syscall.Termios)(&a))
return termios.Tcsetattr(uintptr(t.fd), termios.TCSANOW, (*syscall.Termios)(&a))
} | |
c11368 | error {
return t.setSpeed(baud)
}
} | |
c11369 | t.SetOption(Speed(baud))
} | |
c11370 | termios.Tcflush(uintptr(t.fd), termios.TCIOFLUSH)
} | |
c11371 | rmios.Tcsetattr(uintptr(t.fd), termios.TCIOFLUSH, &t.orig)
} | |
c11372 |
return ioctl(fd, syscall.TIOCMGET, uintptr(unsafe.Pointer(status)))
} | |
c11373 |
return ioctl(fd, syscall.TIOCMSET, uintptr(unsafe.Pointer(status)))
} | |
c11374 |
return ioctl(fd, syscall.TIOCMBIS, uintptr(unsafe.Pointer(status)))
} | |
c11375 |
return ioctl(fd, syscall.TIOCMBIC, uintptr(unsafe.Pointer(status)))
} | |
c11376 | attr.Cc[syscall.VMIN] = 1
attr.Cc[syscall.VTIME] = 0
} | |
c11377 | |= syscall.CS8
attr.Lflag &^= syscall.ECHO | syscall.ICANON | syscall.IEXTEN | syscall.ISIG
attr.Cc[syscall.VMIN] = 1
attr.Cc[syscall.VTIME] = 0
} | |
c11378 | / 1e6 / 100
// ensure valid range
vtime := uint8(clamp(vtimeDeci, 1, 0xff))
return 0, vtime
}
// block indefinitely until we receive at least 1 byte
return 1, 0
} | |
c11379 | *Term) error {
return t.setReadTimeout(d)
}
} | |
c11380 | t.SetOption(ReadTimeout(d))
} | |
c11381 |
return func(t *Term) error {
return t.setFlowControl(kind)
}
} | |
c11382 | t.SetOption(FlowControl(kind))
} | |
c11383 | {
return err
}
return Tcsetattr(fd, TCSADRAIN, &attr)
} | |
c11384 | syscall.TIOCOUTQ, uintptr(unsafe.Pointer(argp)))
} | |
c11385 |
pts, err := open_device(sname)
if err != nil {
return nil, nil, err
}
return os.NewFile(uintptr(ptm), "ptm"), os.NewFile(uintptr(pts), sname), nil
} | |
c11386 | tiosToUnix(attr)
return uint32(C.cfgetispeed((*C.termios_t)(unsafe.Pointer(solTermios))))
} | |
c11387 | C.cfsetispeed((*C.termios_t)(unsafe.Pointer(solTermios)), C.speed_t(speed))
return err
} | |
c11388 | tiosToUnix(attr)
return uint32(C.cfgetospeed((*C.termios_t)(unsafe.Pointer(solTermios))))
} | |
c11389 | C.cfsetospeed((*C.termios_t)(unsafe.Pointer(solTermios)), C.speed_t(speed))
return err
} | |
c11390 |
}
time.Sleep(4 / 10 * time.Second)
return ioctl(fd, syscall.TIOCCBRK, 0)
} | |
c11391 | return syscall.EINVAL
}
return ioctl(fd, syscall.TIOCFLUSH, uintptr(unsafe.Pointer(&com)))
} | |
c11392 | := termios.Tiocoutq(uintptr(t.fd), &n)
return n, err
} | |
c11393 | "base58", encStr)
f.StringVar(&o.Encoding, "e", "base58", encStr+" (shorthand)")
lengthStr := "checksums length in bits (truncate). -1 is default"
f.IntVar(&o.Length, "length", -1, lengthStr)
f.IntVar(&o.Length, "l", -1, lengthStr+" (shorthand)")
return o
} | |
c11394 | {
if o.Length%8 != 0 {
return fmt.Errorf("length must be multiple of 8")
}
o.Length = o.Length / 8
if o.Length > mh.DefaultLengths[o.AlgorithmCode] {
o.Length = mh.DefaultLengths[o.AlgorithmCode]
}
}
return nil
} | |
c11395 | == a {
return true
}
}
return false
} | |
c11396 |
return fmt.Errorf("computed checksum did not match")
}
return nil
} | |
c11397 | return nil, err
}
return mh.Sum(b, o.AlgorithmCode, o.Length)
} | |
c11398 | return Multihash{}, err
}
return Cast(b)
} | |
c11399 | return Multihash{}, ErrInvalidMultihash
}
return Cast(b)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.