_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11300 | AppendRTMTo | train | func (fe *T) AppendRTMTo(aggregate *memmetrics.RTMetrics) {
fe.mu.Lock()
rtmCollect := fe.rtmCollect
fe.mu.Unlock()
if rtmCollect == nil {
return
}
rtmCollect.AppendFeRTMTo(aggregate)
} | go | {
"resource": ""
} |
q11301 | syncServers | train | func syncServers(balancer *roundrobin.Rebalancer, beSrvs []backend.Srv, watcher *rtmcollect.T) {
// First, collect and parse servers to add
newServers := make(map[backend.SrvURLKey]backend.Srv)
for _, newBeSrv := range beSrvs {
newServers[newBeSrv.URLKey()] = newBeSrv
}
// Memorize what endpoints exist in load ... | go | {
"resource": ""
} |
q11302 | New | train | func New() *T {
return &T{
new: make(map[string]int64),
active: make(map[string]int64),
idle: make(map[string]int64),
}
} | go | {
"resource": ""
} |
q11303 | RegisterStateChange | train | func (c *T) RegisterStateChange(conn net.Conn, prev http.ConnState, cur http.ConnState) {
c.mu.Lock()
defer c.mu.Unlock()
if cur == http.StateNew || cur == http.StateIdle || cur == http.StateActive {
c.inc(conn, cur, 1)
}
if cur != http.StateNew {
c.inc(conn, prev, -1)
}
} | go | {
"resource": ""
} |
q11304 | Counts | train | func (c *T) Counts() conntracker.ConnectionStats {
c.mu.Lock()
defer c.mu.Unlock()
return conntracker.ConnectionStats{
http.StateNew: c.copy(c.new),
http.StateActive: c.copy(c.active),
http.StateIdle: c.copy(c.idle),
}
} | go | {
"resource": ""
} |
q11305 | New | train | func New(lsnCfg engine.Listener, router http.Handler, stapler stapler.Stapler,
connTck conntracker.ConnectionTracker, autoCertCache autocert.Cache, wg *sync.WaitGroup,
) (*T, error) {
scopedRouter, err := newScopeRouter(lsnCfg.Scope, router)
if err != nil {
return nil, err
}
return &T{
lsnCfg: lsnCfg,
router... | go | {
"resource": ""
} |
q11306 | Start | train | func (s *T) Start(hostCfgs map[engine.HostKey]engine.Host) error {
log.Infof("%s start", s)
switch s.state {
case srvStateInit:
lsn, err := net.Listen(s.lsnCfg.Address.Network, s.lsnCfg.Address.Address)
if err != nil {
return err
}
lsn = &graceful.TCPKeepAliveListener{TCPListener: lsn.(*net.TCPListener)}... | go | {
"resource": ""
} |
q11307 | OnHostsUpdated | train | func (s *T) OnHostsUpdated(hostCfgs map[engine.HostKey]engine.Host) {
if !s.isTLS() {
return
}
if err := s.reloadTLSCfg(hostCfgs); err != nil {
log.Errorf("Failed to reload TLS config: %v", err)
}
} | go | {
"resource": ""
} |
q11308 | certFuncForHost | train | func certFuncForHost(hostCfg engine.Host, autoCertCache autocert.Cache, s stapler.Stapler) (getCertificateFunc, error) {
ac := hostCfg.Settings.AutoCert
// Each host gets its own Autocert Manager - this allows individual
// certs to use different autocert authorities, as well as auth keys
autoCertMgr := &autocert.... | go | {
"resource": ""
} |
q11309 | certForHost | train | func certForHost(hostCfg engine.Host) (tls.Certificate, error) {
c := hostCfg.Settings.KeyPair
cert, err := tls.X509KeyPair(c.Cert, c.Key)
if err != nil {
return tls.Certificate{}, err
}
return cert, nil
} | go | {
"resource": ""
} |
q11310 | findVulcanUrl | train | func findVulcanUrl(args []string) (string, []string, error) {
for i, arg := range args {
if strings.HasPrefix(arg, "--vulcan=") || strings.HasPrefix(arg, "-vulcan=") {
out := strings.Split(arg, "=")
return out[1], cut(i, i+1, args), nil
} else if strings.HasPrefix(arg, "-vulcan") || strings.HasPrefix(arg, "-... | go | {
"resource": ""
} |
q11311 | NewWithOptions | train | func NewWithOptions(o Options) *Server {
var listener *Listener
if o.Listener != nil {
g, ok := o.Listener.(*Listener)
if !ok {
listener = NewListener(o.Listener)
} else {
listener = g
}
}
if o.Server == nil {
o.Server = new(http.Server)
}
return &Server{
Server: o.Server,
listener: ... | go | {
"resource": ""
} |
q11312 | New | train | func New(addr string, reqHeaders, respHeaders []string) (*Trace, error) {
if _, err := newWriter(addr); err != nil {
return nil, err
}
return &Trace{
ReqHeaders: reqHeaders,
RespHeaders: respHeaders,
Addr: addr,
}, nil
} | go | {
"resource": ""
} |
q11313 | NewHandler | train | func (t *Trace) NewHandler(next http.Handler) (http.Handler, error) {
return newTraceHandler(next, t)
} | go | {
"resource": ""
} |
q11314 | String | train | func (t *Trace) String() string {
return fmt.Sprintf("addr=%v, reqHeaders=%v, respHeaders=%v", t.Addr, t.ReqHeaders, t.RespHeaders)
} | go | {
"resource": ""
} |
q11315 | FromOther | train | func FromOther(t Trace) (plugin.Middleware, error) {
return New(t.Addr, t.ReqHeaders, t.RespHeaders)
} | go | {
"resource": ""
} |
q11316 | FromCli | train | func FromCli(c *cli.Context) (plugin.Middleware, error) {
return New(c.String("addr"), c.StringSlice("reqHeader"), c.StringSlice("respHeader"))
} | go | {
"resource": ""
} |
q11317 | CliFlags | train | func CliFlags() []cli.Flag {
return []cli.Flag{
cli.StringFlag{
Name: "addr",
Usage: "Address of the output, e.g. syslog:///tmp/out.sock",
},
cli.StringSliceFlag{
Name: "reqHeader",
Usage: "if provided, captures headers from requests",
Value: &cli.StringSlice{},
},
cli.StringSliceFlag{
Na... | go | {
"resource": ""
} |
q11318 | Clock | train | func Clock(clock timetools.TimeProvider) StaplerOption {
return func(s *stapler) {
s.clock = clock
}
} | go | {
"resource": ""
} |
q11319 | New | train | func New(opts ...StaplerOption) Stapler {
s := &stapler{
v: make(map[string]*hostStapler),
mtx: &sync.Mutex{},
eventsC: make(chan *stapleFetched),
closeC: make(chan struct{}),
subscribers: make(map[int32]chan *StapleUpdated),
kickC: make(chan bool),
discardC: nil,
//... | go | {
"resource": ""
} |
q11320 | CfgWithStats | train | func (e *BeSrvEntry) CfgWithStats() engine.Server {
cfg := e.beSrvCfg
var err error
cfg.Stats, err = engine.NewRoundTripStats(e.rtm)
if err != nil {
panic(errors.Wrap(err, "must never fail"))
}
return cfg
} | go | {
"resource": ""
} |
q11321 | New | train | func New(handler http.Handler) (*T, error) {
feRTM, err := memmetrics.NewRTMetrics()
if err != nil {
return nil, err
}
return &T{
rtm: feRTM,
beSrvRTMs: make(map[backend.SrvURLKey]BeSrvEntry),
clock: &timetools.RealTime{},
handler: handler,
}, nil
} | go | {
"resource": ""
} |
q11322 | RTStats | train | func (c *T) RTStats() (*engine.RoundTripStats, error) {
c.mu.Lock()
defer c.mu.Unlock()
return engine.NewRoundTripStats(c.rtm)
} | go | {
"resource": ""
} |
q11323 | UpsertServer | train | func (c *T) UpsertServer(beSrv backend.Srv) {
c.mu.Lock()
defer c.mu.Unlock()
c.beSrvRTMs[beSrv.URLKey()] = BeSrvEntry{beSrv.Cfg(), NewRTMetrics()}
} | go | {
"resource": ""
} |
q11324 | RemoveServer | train | func (c *T) RemoveServer(beSrvURLKey backend.SrvURLKey) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.beSrvRTMs, beSrvURLKey)
} | go | {
"resource": ""
} |
q11325 | AppendFeRTMTo | train | func (c *T) AppendFeRTMTo(aggregate *memmetrics.RTMetrics) error {
c.mu.Lock()
defer c.mu.Unlock()
return aggregate.Append(c.rtm)
} | go | {
"resource": ""
} |
q11326 | NewHandler | train | func (c *Spec) NewHandler(next http.Handler) (http.Handler, error) {
return fromSpec(c, next)
} | go | {
"resource": ""
} |
q11327 | NewSpec | train | func NewSpec(condition string, fallback, onTripped, onStandby interface{}, fallbackDuration, recoveryDuration, checkPeriod time.Duration) (*Spec, error) {
spec := &Spec{
Condition: condition,
Fallback: fallback,
OnTripped: onTripped,
OnStandby: onStandby,
RecoveryDuration: recove... | go | {
"resource": ""
} |
q11328 | FromOther | train | func FromOther(c Spec) (plugin.Middleware, error) {
return NewSpec(c.Condition, c.Fallback, c.OnTripped, c.OnStandby, c.FallbackDuration, c.RecoveryDuration, c.CheckPeriod)
} | go | {
"resource": ""
} |
q11329 | FromCli | train | func FromCli(c *cli.Context) (plugin.Middleware, error) {
return NewSpec(c.String("condition"), c.String("fallback"), c.String("onTripped"), c.String("onStandby"), c.Duration("fallbackDuration"), c.Duration("recoveryDuration"), c.Duration("checkPeriod"))
} | go | {
"resource": ""
} |
q11330 | NewTLSConfig | train | func NewTLSConfig(s *TLSSettings) (*tls.Config, error) {
// Parse min and max TLS versions
var min, max uint16
var err error
if s.MinVersion == "" {
min = tls.VersionTLS10
} else if min, err = ParseTLSVersion(s.MinVersion); err != nil {
return nil, err
}
if s.MaxVersion == "" {
max = tls.VersionTLS12
} ... | go | {
"resource": ""
} |
q11331 | NewTLSSessionCache | train | func NewTLSSessionCache(s *TLSSessionCache) (tls.ClientSessionCache, error) {
cacheType := s.Type
if cacheType == "" {
cacheType = LRUCacheType
}
if cacheType != LRUCacheType {
return nil, fmt.Errorf("unsupported session cache type: %v", s.Type)
}
var capacity int
if params := s.Settings; params != nil {
i... | go | {
"resource": ""
} |
q11332 | parseChange | train | func (n *ng) parseChange(response *etcd.Response) (interface{}, error) {
// Order parsers from the most to the least frequently used.
matchers := []MatcherFn{
n.parseBackendServerChange,
n.parseBackendChange,
n.parseFrontendMiddlewareChange,
n.parseFrontendChange,
n.parseHostChange,
n.parseListenerChange,... | go | {
"resource": ""
} |
q11333 | NewHTTPBackend | train | func NewHTTPBackend(id string, s HTTPBackendSettings) (*Backend, error) {
if _, err := s.TransportSettings(); err != nil {
return nil, err
}
return &Backend{
Id: id,
Type: HTTP,
Settings: s,
}, nil
} | go | {
"resource": ""
} |
q11334 | NetErrorRatio | train | func (e *RoundTripStats) NetErrorRatio() float64 {
if e.Counters.Total == 0 {
return 0
}
return (float64(e.Counters.NetErrors) / float64(e.Counters.Total))
} | go | {
"resource": ""
} |
q11335 | AppErrorRatio | train | func (e *RoundTripStats) AppErrorRatio() float64 {
return e.ResponseCodeRatio(http.StatusInternalServerError, http.StatusInternalServerError+1, 200, 300)
} | go | {
"resource": ""
} |
q11336 | Cfg | train | func (s *Srv) Cfg() engine.Server {
return engine.Server{
Id: s.id,
URL: s.rawURL,
}
} | go | {
"resource": ""
} |
q11337 | NewSrvURLKey | train | func NewSrvURLKey(u *url.URL) SrvURLKey {
return SrvURLKey{scheme: u.Scheme, host: u.Host}
} | go | {
"resource": ""
} |
q11338 | NewServer | train | func NewServer(beSrvCfg engine.Server) (Srv, error) {
parsedURL, err := url.Parse(beSrvCfg.URL)
if err != nil {
return Srv{}, errors.Wrapf(err, "bad url %v", beSrvCfg.URL)
}
return Srv{
id: beSrvCfg.Id,
rawURL: beSrvCfg.URL,
parsedURL: parsedURL,
}, nil
} | go | {
"resource": ""
} |
q11339 | New | train | func New(beCfg engine.Backend, opts proxy.Options, beSrvs []Srv) (*T, error) {
tpCfg, err := newTransportCfg(beCfg.HTTPSettings(), opts)
if err != nil {
return nil, errors.Wrap(err, "bad config")
}
return &T{
id: beCfg.Id,
httpCfg: beCfg.HTTPSettings(),
httpTp: newTransport(tpCfg),
srvs: beSrvs,
... | go | {
"resource": ""
} |
q11340 | Key | train | func (be *T) Key() engine.BackendKey {
return engine.BackendKey{Id: be.id}
} | go | {
"resource": ""
} |
q11341 | Update | train | func (be *T) Update(beCfg engine.Backend, opts proxy.Options) (bool, error) {
be.mu.Lock()
defer be.mu.Unlock()
if beCfg.Key() != be.Key() {
return false, errors.Errorf("invalid key, want=%v, got=%v", be.Key(), beCfg.Key())
}
// Config has not changed.
if be.httpCfg.Equals(beCfg.HTTPSettings()) {
return fal... | go | {
"resource": ""
} |
q11342 | UpsertServer | train | func (be *T) UpsertServer(beSrvCfg engine.Server) (bool, error) {
be.mu.Lock()
defer be.mu.Unlock()
beSrv, err := NewServer(beSrvCfg)
if err != nil {
return false, errors.Wrapf(err, "bad config %v", beSrvCfg)
}
if i := be.indexOfServer(beSrvCfg.Id); i != -1 {
if be.srvs[i].URLKey() == beSrv.URLKey() {
ret... | go | {
"resource": ""
} |
q11343 | DeleteServer | train | func (be *T) DeleteServer(beSrvKey engine.ServerKey) bool {
be.mu.Lock()
defer be.mu.Unlock()
i := be.indexOfServer(beSrvKey.Id)
if i == -1 {
log.Warnf("Cannot delete missing server %v from backend %v", beSrvKey.Id, be.id)
return false
}
be.cloneSrvCfgsIfSeen()
lastIdx := len(be.srvs) - 1
copy(be.srvs[i:],... | go | {
"resource": ""
} |
q11344 | Snapshot | train | func (be *T) Snapshot() (*http.Transport, []Srv) {
be.mu.Lock()
defer be.mu.Unlock()
be.srvCfgsSeen = true
return be.httpTp, be.srvs
} | go | {
"resource": ""
} |
q11345 | Server | train | func (be *T) Server(beSrvKey engine.ServerKey) (Srv, bool) {
be.mu.Lock()
defer be.mu.Unlock()
i := be.indexOfServer(beSrvKey.Id)
if i == -1 {
return Srv{}, false
}
return be.srvs[i], true
} | go | {
"resource": ""
} |
q11346 | NewProxy | train | func NewProxy(id int, st stapler.Stapler, o proxy.Options) (proxy.Proxy, error) {
return mux.New(id, st, o)
} | go | {
"resource": ""
} |
q11347 | NewListener | train | func NewListener(l net.Listener) *Listener {
return &Listener{
listener: l,
mutex: &sync.RWMutex{},
open: true,
}
} | go | {
"resource": ""
} |
q11348 | Accept | train | func (l *Listener) Accept() (net.Conn, error) {
conn, err := l.listener.Accept()
if err != nil {
if l.isClosed() {
err = fmt.Errorf("listener already closed: err=(%s)", err)
}
return nil, err
}
return conn, nil
} | go | {
"resource": ""
} |
q11349 | Close | train | func (l *Listener) Close() error {
l.mutex.Lock()
defer l.mutex.Unlock()
if !l.open {
return nil
}
l.open = false
return l.listener.Close()
} | go | {
"resource": ""
} |
q11350 | NewTLSListener | train | func NewTLSListener(inner net.Listener, config *tls.Config) net.Listener {
l := new(TLSListener)
l.Listener = inner
l.config = config
return l
} | go | {
"resource": ""
} |
q11351 | initLogger | train | func (s *Service) initLogger() {
log.SetLevel(s.options.LogSeverity.S)
// If LogFormatter is specified then Log is ignored.
if s.options.LogFormatter != nil {
log.SetOutput(os.Stdout)
log.SetFormatter(s.options.LogFormatter)
return
}
if s.options.Log == "console" {
log.SetOutput(os.Stdout)
log.SetFormatt... | go | {
"resource": ""
} |
q11352 | filesFromString | train | func filesFromString(in string) ([]*proxy.FileDescriptor, error) {
var out []fileDescriptor
if err := json.Unmarshal([]byte(in), &out); err != nil {
return nil, err
}
files := make([]*proxy.FileDescriptor, len(out))
for i, o := range out {
files[i] = &proxy.FileDescriptor{
File: os.NewFile(uintptr(o.File... | go | {
"resource": ""
} |
q11353 | ExampleGeocoder | train | func ExampleGeocoder() {
fmt.Println("Google Geocoding API")
try(google.Geocoder(os.Getenv("GOOGLE_API_KEY")))
fmt.Println("Mapquest Nominatim")
try(nominatim.Geocoder(os.Getenv("MAPQUEST_NOMINATIM_KEY")))
fmt.Println("Mapquest Open streetmaps")
try(open.Geocoder(os.Getenv("MAPQUEST_OPEN_KEY")))
fmt.Println("... | go | {
"resource": ""
} |
q11354 | Geocoder | train | func Geocoder(k string, z int, baseURLs ...string) geo.Geocoder {
key = k
var url string
if len(baseURLs) > 0 {
url = baseURLs[0]
} else {
url = defaultURL
}
if z > minZoom && z <= maxZoom {
zoom = z
} else {
zoom = defaultZoom
}
return geo.HTTPGeocoder{
EndpointBuilder: baseURL(url),
Resp... | go | {
"resource": ""
} |
q11355 | Geocoder | train | func Geocoder(addressToLocation AddressToLocation, LocationToAddress LocationToAddress) geo.Geocoder {
return dataGeocoder{
AddressToLocation: addressToLocation,
LocationToAddress: LocationToAddress,
}
} | go | {
"resource": ""
} |
q11356 | Geocoder | train | func Geocoder(geocoder geo.Geocoder, cache *cache.Cache) geo.Geocoder {
return cachedGeocoder{Geocoder: geocoder, Cache: cache}
} | go | {
"resource": ""
} |
q11357 | Geocoder | train | func Geocoder(token string, baseURLs ...string) geo.Geocoder {
return geo.HTTPGeocoder{
EndpointBuilder: baseURL(getUrl(token, baseURLs...)),
ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | go | {
"resource": ""
} |
q11358 | GeocoderWithURL | train | func GeocoderWithURL(nominatimURL string) geo.Geocoder {
return geo.HTTPGeocoder{
EndpointBuilder: baseURL(nominatimURL),
ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | go | {
"resource": ""
} |
q11359 | response | train | func response(ctx context.Context, url string, obj ResponseParser) error {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return err
}
req = req.WithContext(ctx)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll... | go | {
"resource": ""
} |
q11360 | ParseFloat | train | func ParseFloat(value string) float64 {
f, _ := strconv.ParseFloat(value, 64)
return f
} | go | {
"resource": ""
} |
q11361 | Geocoder | train | func Geocoder(id, code string, radius int, baseURLs ...string) geo.Geocoder {
if radius > 0 {
r = radius
}
p := "gen=9&app_id=" + id + "&app_code=" + code
return geo.HTTPGeocoder{
EndpointBuilder: baseURL{
getGeocodeURL(p, baseURLs...),
getReverseGeocodeURL(p, baseURLs...)},
ResponseParserFactory: func(... | go | {
"resource": ""
} |
q11362 | Locality | train | func (a Address) Locality() string {
var locality string
if a.City != "" {
locality = a.City
} else if a.Town != "" {
locality = a.Town
} else if a.Village != "" {
locality = a.Village
}
return locality
} | go | {
"resource": ""
} |
q11363 | Street | train | func (a Address) Street() string {
var street string
if a.Road != "" {
street = a.Road
} else if a.Pedestrian != "" {
street = a.Pedestrian
} else if a.Path != "" {
street = a.Path
} else if a.Cycleway != "" {
street = a.Cycleway
} else if a.Footway != "" {
street = a.Footway
} else if a.Highway != ""... | go | {
"resource": ""
} |
q11364 | SetOption | train | func (t *Term) SetOption(options ...func(*Term) error) error {
for _, opt := range options {
if err := opt(t); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q11365 | Close | train | func (t *Term) Close() error {
err := syscall.Close(t.fd)
t.fd = -1
return err
} | go | {
"resource": ""
} |
q11366 | CBreakMode | train | func CBreakMode(t *Term) error {
var a attr
if err := termios.Tcgetattr(uintptr(t.fd), (*syscall.Termios)(&a)); err != nil {
return err
}
termios.Cfmakecbreak((*syscall.Termios)(&a))
return termios.Tcsetattr(uintptr(t.fd), termios.TCSANOW, (*syscall.Termios)(&a))
} | go | {
"resource": ""
} |
q11367 | RawMode | train | func RawMode(t *Term) error {
var a attr
if err := termios.Tcgetattr(uintptr(t.fd), (*syscall.Termios)(&a)); err != nil {
return err
}
termios.Cfmakeraw((*syscall.Termios)(&a))
return termios.Tcsetattr(uintptr(t.fd), termios.TCSANOW, (*syscall.Termios)(&a))
} | go | {
"resource": ""
} |
q11368 | Speed | train | func Speed(baud int) func(*Term) error {
return func(t *Term) error {
return t.setSpeed(baud)
}
} | go | {
"resource": ""
} |
q11369 | SetSpeed | train | func (t *Term) SetSpeed(baud int) error {
return t.SetOption(Speed(baud))
} | go | {
"resource": ""
} |
q11370 | Flush | train | func (t *Term) Flush() error {
return termios.Tcflush(uintptr(t.fd), termios.TCIOFLUSH)
} | go | {
"resource": ""
} |
q11371 | Restore | train | func (t *Term) Restore() error {
return termios.Tcsetattr(uintptr(t.fd), termios.TCIOFLUSH, &t.orig)
} | go | {
"resource": ""
} |
q11372 | Tiocmget | train | func Tiocmget(fd uintptr, status *int) error {
return ioctl(fd, syscall.TIOCMGET, uintptr(unsafe.Pointer(status)))
} | go | {
"resource": ""
} |
q11373 | Tiocmset | train | func Tiocmset(fd uintptr, status *int) error {
return ioctl(fd, syscall.TIOCMSET, uintptr(unsafe.Pointer(status)))
} | go | {
"resource": ""
} |
q11374 | Tiocmbis | train | func Tiocmbis(fd uintptr, status *int) error {
return ioctl(fd, syscall.TIOCMBIS, uintptr(unsafe.Pointer(status)))
} | go | {
"resource": ""
} |
q11375 | Tiocmbic | train | func Tiocmbic(fd uintptr, status *int) error {
return ioctl(fd, syscall.TIOCMBIC, uintptr(unsafe.Pointer(status)))
} | go | {
"resource": ""
} |
q11376 | Cfmakecbreak | train | func Cfmakecbreak(attr *syscall.Termios) {
attr.Lflag &^= syscall.ECHO | syscall.ICANON
attr.Cc[syscall.VMIN] = 1
attr.Cc[syscall.VTIME] = 0
} | go | {
"resource": ""
} |
q11377 | Cfmakeraw | train | func Cfmakeraw(attr *syscall.Termios) {
attr.Iflag &^= syscall.BRKINT | syscall.ICRNL | syscall.INPCK | syscall.ISTRIP | syscall.IXON
attr.Oflag &^= syscall.OPOST
attr.Cflag &^= syscall.CSIZE | syscall.PARENB
attr.Cflag |= syscall.CS8
attr.Lflag &^= syscall.ECHO | syscall.ICANON | syscall.IEXTEN | syscall.ISIG
at... | go | {
"resource": ""
} |
q11378 | timeoutVals | train | func timeoutVals(d time.Duration) (uint8, uint8) {
if d > 0 {
// VTIME is expressed in terms of deciseconds
vtimeDeci := d.Nanoseconds() / 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
} | go | {
"resource": ""
} |
q11379 | ReadTimeout | train | func ReadTimeout(d time.Duration) func(*Term) error {
return func(t *Term) error {
return t.setReadTimeout(d)
}
} | go | {
"resource": ""
} |
q11380 | SetReadTimeout | train | func (t *Term) SetReadTimeout(d time.Duration) error {
return t.SetOption(ReadTimeout(d))
} | go | {
"resource": ""
} |
q11381 | FlowControl | train | func FlowControl(kind int) func(*Term) error {
return func(t *Term) error {
return t.setFlowControl(kind)
}
} | go | {
"resource": ""
} |
q11382 | SetFlowControl | train | func (t *Term) SetFlowControl(kind int) error {
return t.SetOption(FlowControl(kind))
} | go | {
"resource": ""
} |
q11383 | Tcdrain | train | func Tcdrain(fd uintptr) error {
// simulate drain with TCSADRAIN
var attr syscall.Termios
if err := Tcgetattr(fd, &attr); err != nil {
return err
}
return Tcsetattr(fd, TCSADRAIN, &attr)
} | go | {
"resource": ""
} |
q11384 | Tiocoutq | train | func Tiocoutq(fd uintptr, argp *int) error {
return ioctl(fd, syscall.TIOCOUTQ, uintptr(unsafe.Pointer(argp)))
} | go | {
"resource": ""
} |
q11385 | Pty | train | func Pty() (*os.File, *os.File, error) {
ptm, err := open_pty_master()
if err != nil {
return nil, nil, err
}
sname, err := Ptsname(ptm)
if err != nil {
return nil, nil, err
}
err = grantpt(ptm)
if err != nil {
return nil, nil, err
}
err = unlockpt(ptm)
if err != nil {
return nil, nil, err
}
pt... | go | {
"resource": ""
} |
q11386 | Cfgetispeed | train | func Cfgetispeed(attr *syscall.Termios) uint32 {
solTermios := tiosToUnix(attr)
return uint32(C.cfgetispeed((*C.termios_t)(unsafe.Pointer(solTermios))))
} | go | {
"resource": ""
} |
q11387 | Cfsetispeed | train | func Cfsetispeed(attr *syscall.Termios, speed uintptr) error {
solTermios := tiosToUnix(attr)
_, err := C.cfsetispeed((*C.termios_t)(unsafe.Pointer(solTermios)), C.speed_t(speed))
return err
} | go | {
"resource": ""
} |
q11388 | Cfgetospeed | train | func Cfgetospeed(attr *syscall.Termios) uint32 {
solTermios := tiosToUnix(attr)
return uint32(C.cfgetospeed((*C.termios_t)(unsafe.Pointer(solTermios))))
} | go | {
"resource": ""
} |
q11389 | Cfsetospeed | train | func Cfsetospeed(attr *syscall.Termios, speed uintptr) error {
solTermios := tiosToUnix(attr)
_, err := C.cfsetospeed((*C.termios_t)(unsafe.Pointer(solTermios)), C.speed_t(speed))
return err
} | go | {
"resource": ""
} |
q11390 | Tcsendbreak | train | func Tcsendbreak(fd, duration uintptr) error {
if err := ioctl(fd, syscall.TIOCSBRK, 0); err != nil {
return err
}
time.Sleep(4 / 10 * time.Second)
return ioctl(fd, syscall.TIOCCBRK, 0)
} | go | {
"resource": ""
} |
q11391 | Tcflush | train | func Tcflush(fd, which uintptr) error {
var com int
switch which {
case syscall.TCIFLUSH:
com = FREAD
case syscall.TCOFLUSH:
com = FWRITE
case syscall.TCIOFLUSH:
com = FREAD | FWRITE
default:
return syscall.EINVAL
}
return ioctl(fd, syscall.TIOCFLUSH, uintptr(unsafe.Pointer(&com)))
} | go | {
"resource": ""
} |
q11392 | Buffered | train | func (t *Term) Buffered() (int, error) {
var n int
err := termios.Tiocoutq(uintptr(t.fd), &n)
return n, err
} | go | {
"resource": ""
} |
q11393 | SetupFlags | train | func SetupFlags(f *flag.FlagSet) *Options {
// TODO: add arg for adding opt prefix and/or overriding opts
o := new(Options)
algoStr := "one of: " + strings.Join(FlagValues.Algorithms, ", ")
f.StringVar(&o.Algorithm, "algorithm", "sha2-256", algoStr)
f.StringVar(&o.Algorithm, "a", "sha2-256", algoStr+" (shorthand)... | go | {
"resource": ""
} |
q11394 | ParseError | train | func (o *Options) ParseError() error {
if !strIn(o.Encoding, FlagValues.Encodings) {
return fmt.Errorf("encoding '%s' not %s", o.Encoding, FlagValues.Encodings)
}
if !strIn(o.Algorithm, FlagValues.Algorithms) {
return fmt.Errorf("algorithm '%s' not %s", o.Algorithm, FlagValues.Algorithms)
}
var found bool
o... | go | {
"resource": ""
} |
q11395 | strIn | train | func strIn(a string, set []string) bool {
for _, s := range set {
if s == a {
return true
}
}
return false
} | go | {
"resource": ""
} |
q11396 | Check | train | func (o *Options) Check(r io.Reader, h1 mh.Multihash) error {
h2, err := o.Multihash(r)
if err != nil {
return err
}
if !bytes.Equal(h1, h2) {
return fmt.Errorf("computed checksum did not match")
}
return nil
} | go | {
"resource": ""
} |
q11397 | Multihash | train | func (o *Options) Multihash(r io.Reader) (mh.Multihash, error) {
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return mh.Sum(b, o.AlgorithmCode, o.Length)
} | go | {
"resource": ""
} |
q11398 | FromHexString | train | func FromHexString(s string) (Multihash, error) {
b, err := hex.DecodeString(s)
if err != nil {
return Multihash{}, err
}
return Cast(b)
} | go | {
"resource": ""
} |
q11399 | FromB58String | train | func FromB58String(s string) (m Multihash, err error) {
b, err := b58.Decode(s)
if err != nil {
return Multihash{}, ErrInvalidMultihash
}
return Cast(b)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.