_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 balancer at the moment
oldServers := make(map[backend.SrvURLKey]*url.URL)
for _, oldBeSrvURL := range balancer.Servers() {
oldServers[backend.NewSrvURLKey(oldBeSrvURL)] = oldBeSrvURL
}
// 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.UpsertServer(newBeSrv)
}
}
// Second, remove endpoints that should not be there any more
for oldBeSrvURLKey, oldBeSrvURL := range oldServers {
if _, ok := newServers[oldBeSrvURLKey]; !ok {
if err := balancer.RemoveServer(oldBeSrvURL); err != nil {
log.Errorf("Failed to remove %v, err: %v", oldBeSrvURL, err)
}
watcher.RemoveServer(oldBeSrvURLKey)
}
}
} | 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: router,
stapler: stapler,
connTck: connTck,
autoCertCache: autoCertCache,
serveWg: wg,
scopedRouter: scopedRouter,
state: srvStateInit,
}, nil
} | 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)}
if s.isProxyProto() {
lsn = &proxyproto.Listener{
Listener: lsn,
ProxyHeaderTimeout: s.options.ReadTimeout,
}
}
if s.isTLS() {
config, err := s.newTLSCfg(hostCfgs)
if err != nil {
return err
}
lsn = graceful.NewTLSListener(lsn, config)
}
s.srv = graceful.NewWithOptions(
graceful.Options{
Server: s.newHTTPServer(),
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 state", s)
} | 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.Manager{
Prompt: autocert.AcceptTOS,
Cache: autoCertCache,
HostPolicy: autocert.HostWhitelist(hostCfg.Name),
Email: ac.Email,
}
if ac.RenewBefore > 0 {
autoCertMgr.RenewBefore = ac.RenewBefore
}
// if either directory or key are non-empty, we need to generate
// a custom ACME client to override either.
if ac.Key != "" || ac.DirectoryURL != "" {
// If DirectoryURL is empty, the default Let's Encrypt URL will be picked.
autoCertMgr.Client = &acme.Client{
DirectoryURL: ac.DirectoryURL,
}
// If Key is non-empty, then decode it as RSA or EC which are the only two keys
// we support. Go's crypto library doesn't support a generic function to provide back
// a private key interface.
if ac.Key != "" {
block, _ := pem.Decode([]byte(ac.Key))
if block == nil {
return nil, fmt.Errorf("Autocert Key PEM Block for Host %s is invalid.", hostCfg.Name)
} else if block.Type == "RSA PRIVATE KEY" {
rsaPrivateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, errors.Wrapf(err, "Error parsing Autocert Key block of type %s, for Host %s, as an RSA Private Key.", block.Type, hostCfg.Name)
}
autoCertMgr.Client.Key = rsaPrivateKey
} else if block.Type == "EC PRIVATE KEY" {
ecPrivateKey, err := x509.ParseECPrivateKey(block.Bytes)
if err != nil {
return nil, errors.Wrapf(err, "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 PRIVATE KEY.", hostCfg.Name, block.Type)
}
}
}
getCertFuncForStapling := stapler.WithGetCertFunc(hostCfg.Name, stapler.GetCertificateFunc(autoCertMgr.GetCertificate))
// Wrap the GetCert for this host, so we can generate and staple
// an optional OCSP response when requested.
stapledGetCert := func(info *tls.ClientHelloInfo) (*tls.Certificate, error) {
keyPair, err := autoCertMgr.GetCertificate(info)
ocspStapleToCert(s, hostCfg, keyPair, getCertFuncForStapling)
return keyPair, err
}
return stapledGetCert, nil
} | 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, "--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, nil
} | 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: listener,
stateHandler: o.StateHandler,
shutdown: make(chan bool),
shutdownFinished: make(chan bool, 1),
wg: new(sync.WaitGroup),
connToProps: make(map[net.Conn]connProperties),
}
} | 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{
Name: "respHeader",
Usage: "if provided, captures headers from response",
Value: &cli.StringSlice{},
},
}
} | 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,
// setup transport more aggressive timeouts for OCSP staple responses
client: &http.Client{
Transport: &http.Transport{
Dial: (&net.Dialer{
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
} | 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: recoveryDuration,
FallbackDuration: fallbackDuration,
CheckPeriod: checkPeriod,
}
if _, err := fromSpec(spec, nil); err != nil {
return nil, err
}
return spec, nil
} | 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
} else if max, err = ParseTLSVersion(s.MaxVersion); err != nil {
return nil, err
}
var css []uint16
if len(s.CipherSuites) == 0 {
css = []uint16{
tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_RSA_WITH_AES_128_CBC_SHA,
}
} else {
css = make([]uint16, len(s.CipherSuites))
for i, suite := range s.CipherSuites {
cs, err := ParseCipherSuite(suite)
if err != nil {
return nil, err
}
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: cache,
PreferServerCipherSuites: s.PreferServerCipherSuites,
CipherSuites: css,
InsecureSkipVerify: s.InsecureSkipVerify,
}, nil
} | 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 {
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(capacity), nil
} | 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,
}
for _, matcher := range matchers {
a, err := matcher(response)
if a != nil || err != nil {
return a, err
}
}
return nil, nil
} | 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,
}, nil
} | 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 false, nil
}
tpCfg, err := newTransportCfg(beCfg.HTTPSettings(), opts)
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
} | 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() {
return false, nil
}
be.cloneSrvCfgsIfSeen()
be.srvs[i] = beSrv
return true, nil
}
be.cloneSrvCfgsIfSeen()
be.srvs = append(be.srvs, beSrv)
return true, nil
} | 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:], be.srvs[i+1:])
be.srvs[lastIdx] = Srv{}
be.srvs = be.srvs[:lastIdx]
return true
} | 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.SetFormatter(&log.TextFormatter{})
return
}
var err error
if s.options.Log == "syslog" {
var devNull *os.File
devNull, err = os.OpenFile("/dev/null", os.O_WRONLY, 0)
if err == nil {
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 == "json" {
log.SetOutput(os.Stdout)
log.SetFormatter(&log.JSONFormatter{})
return
}
if s.options.Log == "logstash" {
log.SetOutput(os.Stdout)
log.SetFormatter(&logrus_logstash.LogstashFormatter{Fields: log.Fields{"type": "logs"}})
return
}
log.SetOutput(os.Stdout)
log.SetFormatter(&log.TextFormatter{})
log.Warnf("Failed to initialized logger. Fallback to default: logger=%s, err=(%s)", s.options.Log, err)
} | 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.FileFD), o.FileName),
Address: o.Address,
}
}
return files, nil
} | 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("OpenCage Data")
try(opencage.Geocoder(os.Getenv("OPENCAGE_API_KEY")))
fmt.Println("HERE API")
try(here.Geocoder(os.Getenv("HERE_APP_ID"), os.Getenv("HERE_APP_CODE"), radius))
fmt.Println("Bing Geocoding API")
try(bing.Geocoder(os.Getenv("BING_API_KEY")))
fmt.Println("Mapbox API")
try(mapbox.Geocoder(os.Getenv("MAPBOX_API_KEY")))
fmt.Println("OpenStreetMap")
try(openstreetmap.Geocoder())
fmt.Println("PickPoint")
try(pickpoint.Geocoder(os.Getenv("PICKPOINT_API_KEY")))
fmt.Println("LocationIQ")
try(locationiq.Geocoder(os.Getenv("LOCATIONIQ_API_KEY"), zoom))
fmt.Println("ArcGIS")
try(arcgis.Geocoder(os.Getenv("ARCGIS_TOKEN")))
fmt.Println("geocod.io")
try(geocod.Geocoder(os.Getenv("GEOCOD_API_KEY")))
fmt.Println("Mapzen")
try(mapzen.Geocoder(os.Getenv("MAPZEN_API_KEY")))
fmt.Println("TomTom")
try(tomtom.Geocoder(os.Getenv("TOMTOM_API_KEY")))
fmt.Println("Yandex")
try(yandex.Geocoder(os.Getenv("YANDEX_API_KEY")))
// Chained geocoder will fallback to subsequent geocoders
fmt.Println("ChainedAPI[OpenStreetmap -> Google]")
try(chained.Geocoder(
openstreetmap.Geocoder(),
google.Geocoder(os.Getenv("GOOGLE_API_KEY")),
))
// Output: Google Geocoding API
// Melbourne VIC location is (-37.813611, 144.963056)
// Address of (-37.813611,144.963056) is 197 Elizabeth St, Melbourne VIC 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"197 Elizabeth St, Melbourne VIC 3000, Australia",
// Street:"Elizabeth Street", HouseNumber:"197", Suburb:"", Postcode:"3000", State:"Victoria",
// StateDistrict:"Melbourne City", County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// Mapquest Nominatim
// Melbourne VIC location is (-37.814218, 144.963161)
// Address of (-37.813611,144.963056) is Melbourne's GPO, Postal Lane, Melbourne, City of Melbourne, Greater Melbourne, Victoria, 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"Melbourne's GPO, Postal Lane, Melbourne, City of Melbourne,
// Greater Melbourne, Victoria, 3000, Australia", Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne",
// Postcode:"3000", State:"Victoria", StateDistrict:"", County:"City of Melbourne", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// Mapquest Open streetmaps
// Melbourne VIC location is (-37.814218, 144.963161)
// Address of (-37.813611,144.963056) is Elizabeth Street, Melbourne, Victoria, AU
// Detailed address: &geo.Address{FormattedAddress:"Elizabeth Street, 3000, Melbourne, Victoria, AU",
// Street:"Elizabeth Street", HouseNumber:"", Suburb:"", Postcode:"3000", State:"Victoria", StateDistrict:"",
// County:"", Country:"", CountryCode:"AU", City:"Melbourne"}
//
// OpenCage Data
// Melbourne VIC location is (-37.814217, 144.963161)
// Address of (-37.813611,144.963056) is Melbourne's GPO, Postal Lane, Melbourne VIC 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"Melbourne's GPO, Postal Lane, Melbourne VIC 3000, Australia",
// Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne (3000)", Postcode:"3000", State:"Victoria",
// StateDistrict:"", County:"City of Melbourne", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// HERE API
// Melbourne VIC location is (-37.817530, 144.967150)
// Address of (-37.813611,144.963056) is 197 Elizabeth St, Melbourne VIC 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"197 Elizabeth St, Melbourne VIC 3000, Australia", Street:"Elizabeth St",
// HouseNumber:"197", Suburb:"", Postcode:"3000", State:"Victoria", StateDistrict:"", County:"", Country:"Australia",
// CountryCode:"AUS", City:"Melbourne"}
//
// Bing Geocoding API
// Melbourne VIC location is (-37.824299, 144.977997)
// Address of (-37.813611,144.963056) is Elizabeth St, Melbourne, VIC 3000
// Detailed address: &geo.Address{FormattedAddress:"Elizabeth St, Melbourne, VIC 3000", Street:"Elizabeth St",
// HouseNumber:"", Suburb:"", Postcode:"3000", State:"", StateDistrict:"", County:"", Country:"Australia", CountryCode:"", City:"Melbourne"}
//
// Mapbox API
// Melbourne VIC location is (-37.814200, 144.963200)
// Address of (-37.813611,144.963056) is Elwood Park Playground, Melbourne, Victoria 3000, Australia
// Detailed address: &geo.Address{FormattedAddress:"Elwood Park Playground, Melbourne, Victoria 3000, Australia",
// Street:"Elwood Park Playground", HouseNumber:"", Suburb:"", Postcode:"3000", State:"Victoria", StateDistrict:"",
// County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// OpenStreetMap
// Melbourne VIC location is (-37.814217, 144.963161)
// 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, Australia", Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne", Postcode:"3000", State:"Victoria",
// StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// PickPoint
// Melbourne VIC location is (-37.814217, 144.963161)
// 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, Australia", Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne", Postcode:"3000", State:"Victoria",
// StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// LocationIQ
// Melbourne VIC location is (-37.814217, 144.963161)
// 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, Australia", Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne", Postcode:"3000", State:"Victoria",
// StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
//
// ArcGIS
// Melbourne VIC location is (-37.817530, 144.967150)
// Address of (-37.813611,144.963056) is Melbourne's Gpo
// Detailed address: &geo.Address{FormattedAddress:"Melbourne's Gpo", Street:"350 Bourke Street Mall", HouseNumber:"350", Suburb:"", Postcode:"3000", State:"Victoria", StateDistrict:"", County:"", Country:"", CountryCode:"AUS", City:""}
//
// geocod.io
// Melbourne VIC location is (28.079357, -80.623618)
// got <nil> address
//
// Mapzen
// Melbourne VIC location is (45.551136, 11.533929)
// Address of (-37.813611,144.963056) is Stop 3: Bourke Street Mall, Bourke Street, Melbourne, Australia
// Detailed address: &geo.Address{FormattedAddress:"Stop 3: Bourke Street Mall, Bourke Street, Melbourne, Australia", Street:"", HouseNumber:"", Suburb:"", Postcode:"", State:"Victoria", StateDistrict:"", County:"", Country:"Australia", CountryCode:"AUS", City:""}
//
// TomTom
// Melbourne VIC location is (-37.815340, 144.963230)
// Address of (-37.813611,144.963056) is Doyles Road, Elaine, West Central Victoria, Victoria, 3334
// Detailed address: &geo.Address{FormattedAddress:"Doyles Road, Elaine, West Central Victoria, Victoria, 3334", Street:"Doyles Road", HouseNumber:"", Suburb:"", Postcode:"3334", State:"Victoria", StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU", City:"Elaine"}
//
// Yandex
// Melbourne VIC location is (41.926823, 2.254232)
// Address of (-37.813611,144.963056) is Victoria, City of Melbourne, Elizabeth Street
// Detailed address: &geo.Address{FormattedAddress:"Victoria, City of Melbourne, Elizabeth Street", Street:"Elizabeth Street",
// HouseNumber:"", Suburb:"", Postcode:"", State:"Victoria", StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU",
// City:"City of Melbourne"}
//
// ChainedAPI[OpenStreetmap -> Google]
// Melbourne VIC location is (-37.814217, 144.963161)
// 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, Australia", Street:"Postal Lane", HouseNumber:"", Suburb:"Melbourne", Postcode:"3000", State:"Victoria",
// StateDistrict:"", County:"", Country:"Australia", CountryCode:"AU", City:"Melbourne"}
} | 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),
ResponseParserFactory: func() geo.ResponseParser { return &geocodeResponse{} },
}
} | 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(resp.Body)
if err != nil {
return err
}
body := 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
} | 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() geo.ResponseParser { return &geocodeResponse{} },
}
} | 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 != "" {
street = a.Highway
}
return street
} | 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
attr.Cc[syscall.VMIN] = 1
attr.Cc[syscall.VTIME] = 0
} | 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
}
pts, err := open_device(sname)
if err != nil {
return nil, nil, err
}
return os.NewFile(uintptr(ptm), "ptm"), os.NewFile(uintptr(pts), sname), nil
} | 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)")
encStr := "one of: " + strings.Join(FlagValues.Encodings, ", ")
f.StringVar(&o.Encoding, "encoding", "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
} | 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.AlgorithmCode, found = mh.Names[o.Algorithm]
if !found {
return fmt.Errorf("algorithm '%s' not found (lib error, pls report).", o.Algorithm)
}
if o.Length >= 0 {
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
} | 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.