_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q9400 | CreateFanout | train | func CreateFanout(upstream chan *types.VmResponse, size int, block bool) *Fanout {
fo := &Fanout{
size: size,
upstream: upstream,
clients: []chan *types.VmResponse{},
closeSignal: make(chan *types.VmResponse, 1),
running: !block,
lock: sync.RWMutex{},
}
if !block {
fo.start()
}
return fo
} | go | {
"resource": ""
} |
q9401 | loadProcessConfig | train | func loadProcessConfig(path string) (*specs.Process, error) {
f, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return nil, fmt.Errorf("JSON configuration file for %s not found", path)
}
return nil, err
}
defer f.Close()
var s *specs.Process
if err := json.NewDecoder(f).Decode(&s); err != nil {
return nil, err
}
return s, nil
} | go | {
"resource": ""
} |
q9402 | preCreateDirs | train | func preCreateDirs(rootfs string) error {
dirs := []string{
"proc",
"sys",
"dev",
"lib/modules",
}
for _, dir := range dirs {
err := createIfNotExists(filepath.Join(rootfs, dir), true)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q9403 | allInterfaces | train | func (nc *NetworkContext) allInterfaces() (nics []*InterfaceCreated) {
nc.slotLock.Lock()
defer nc.slotLock.Unlock()
for _, v := range nc.eth {
if v != nil {
nics = append(nics, v)
}
}
return
} | go | {
"resource": ""
} |
q9404 | lockSandbox | train | func lockSandbox(sandboxPath string) (*os.File, error) {
lockFilePath := filepath.Join(sandboxPath, "sandbox.lock")
lockFile, err := os.OpenFile(lockFilePath, os.O_RDWR|os.O_CREATE, 0755)
if err != nil {
return nil, err
}
err = syscall.Flock(int(lockFile.Fd()), syscall.LOCK_EX)
if err != nil {
lockFile.Close()
return nil, err
}
return lockFile, nil
} | go | {
"resource": ""
} |
q9405 | unlockSandbox | train | func unlockSandbox(lockFile *os.File) error {
if lockFile == nil {
return fmt.Errorf("lockFile cannot be empty")
}
err := syscall.Flock(int(lockFile.Fd()), syscall.LOCK_UN)
if err != nil {
return err
}
lockFile.Close()
return nil
} | go | {
"resource": ""
} |
q9406 | SendVmEvent | train | func (ctx *VmContext) SendVmEvent(ev VmEvent) error {
ctx.lock.RLock()
defer ctx.lock.RUnlock()
if ctx.handler == nil {
return fmt.Errorf("VmContext(%s): event handler already shutdown.", ctx.Id)
}
ctx.Hub <- ev
return nil
} | go | {
"resource": ""
} |
q9407 | ReadByte | train | func (c *Conn) ReadByte() (b byte, err error) {
retry := true
for retry && err == nil {
b, retry, err = c.tryReadByte()
}
return
} | go | {
"resource": ""
} |
q9408 | ReadRune | train | func (c *Conn) ReadRune() (r rune, size int, err error) {
loop:
r, size, err = c.r.ReadRune()
if err != nil {
return
}
if r != unicode.ReplacementChar || size != 1 {
// Properly readed rune
return
}
// Bad rune
err = c.r.UnreadRune()
if err != nil {
return
}
// Read telnet command or escaped IAC
_, retry, err := c.tryReadByte()
if err != nil {
return
}
if retry {
// This bad rune was a beginning of telnet command. Try read next rune.
goto loop
}
// Return escaped IAC as unicode.ReplacementChar
return
} | go | {
"resource": ""
} |
q9409 | Read | train | func (c *Conn) Read(buf []byte) (int, error) {
var n int
for n < len(buf) {
b, err := c.ReadByte()
if err != nil {
return n, err
}
//log.Printf("char: %d %q", b, b)
buf[n] = b
n++
if c.r.Buffered() == 0 {
// Try don't block if can return some data
break
}
}
return n, nil
} | go | {
"resource": ""
} |
q9410 | ReadBytes | train | func (c *Conn) ReadBytes(delim byte) ([]byte, error) {
var line []byte
for {
b, err := c.ReadByte()
if err != nil {
return nil, err
}
line = append(line, b)
if b == delim {
break
}
}
return line, nil
} | go | {
"resource": ""
} |
q9411 | SkipBytes | train | func (c *Conn) SkipBytes(delim byte) error {
for {
b, err := c.ReadByte()
if err != nil {
return err
}
if b == delim {
break
}
}
return nil
} | go | {
"resource": ""
} |
q9412 | ReadString | train | func (c *Conn) ReadString(delim byte) (string, error) {
bytes, err := c.ReadBytes(delim)
return string(bytes), err
} | go | {
"resource": ""
} |
q9413 | ReadUntilIndex | train | func (c *Conn) ReadUntilIndex(delims ...string) ([]byte, int, error) {
return c.readUntil(true, delims...)
} | go | {
"resource": ""
} |
q9414 | ReadUntil | train | func (c *Conn) ReadUntil(delims ...string) ([]byte, error) {
d, _, err := c.readUntil(true, delims...)
return d, err
} | go | {
"resource": ""
} |
q9415 | SkipUntilIndex | train | func (c *Conn) SkipUntilIndex(delims ...string) (int, error) {
_, i, err := c.readUntil(false, delims...)
return i, err
} | go | {
"resource": ""
} |
q9416 | SkipUntil | train | func (c *Conn) SkipUntil(delims ...string) error {
_, _, err := c.readUntil(false, delims...)
return err
} | go | {
"resource": ""
} |
q9417 | Write | train | func (c *Conn) Write(buf []byte) (int, error) {
search := "\xff"
if c.unixWriteMode {
search = "\xff\n"
}
var (
n int
err error
)
for len(buf) > 0 {
var k int
i := bytes.IndexAny(buf, search)
if i == -1 {
k, err = c.Conn.Write(buf)
n += k
break
}
k, err = c.Conn.Write(buf[:i])
n += k
if err != nil {
break
}
switch buf[i] {
case LF:
k, err = c.Conn.Write([]byte{CR, LF})
case cmdIAC:
k, err = c.Conn.Write([]byte{cmdIAC, cmdIAC})
}
n += k
if err != nil {
break
}
buf = buf[i+1:]
}
return n, err
} | go | {
"resource": ""
} |
q9418 | AssociateVm | train | func AssociateVm(vmId string, data []byte) (*Vm, error) {
var (
PodEvent = make(chan VmEvent, 128)
Status = make(chan *types.VmResponse, 128)
err error
)
vm := newVm(vmId, 0, 0)
vm.ctx, err = VmAssociate(vm.Id, PodEvent, Status, data)
if err != nil {
vm.Log(ERROR, "cannot associate with vm: %v", err)
return nil, err
}
vm.clients = CreateFanout(Status, 128, false)
return vm, nil
} | go | {
"resource": ""
} |
q9419 | setupNetworkNsTrap | train | func setupNetworkNsTrap(netNs2Containerd func(NetlinkUpdate)) {
// Subscribe for links change event
chLink := make(chan netlink.LinkUpdate)
doneLink := make(chan struct{})
defer close(doneLink)
if err := netlink.LinkSubscribe(chLink, doneLink); err != nil {
glog.Fatal(err)
}
// Subscribe for addresses change event
chAddr := make(chan netlink.AddrUpdate)
doneAddr := make(chan struct{})
defer close(doneAddr)
if err := netlink.AddrSubscribe(chAddr, doneAddr); err != nil {
glog.Fatal(err)
}
// Subscribe for route change event
chRoute := make(chan netlink.RouteUpdate)
doneRoute := make(chan struct{})
defer close(doneRoute)
if err := netlink.RouteSubscribe(chRoute, doneRoute); err != nil {
glog.Fatal(err)
}
for {
select {
case updateLink := <-chLink:
handleLink(updateLink, netNs2Containerd)
case updateAddr := <-chAddr:
handleAddr(updateAddr, netNs2Containerd)
case updateRoute := <-chRoute:
handleRoute(updateRoute, netNs2Containerd)
}
}
} | go | {
"resource": ""
} |
q9420 | fatal | train | func fatal(err error) {
// make sure the error is written to the logger
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
} | go | {
"resource": ""
} |
q9421 | NewSpecError | train | func NewSpecError(id, cause string) *CommonError {
return &CommonError{
errType: ET_SPEC,
contextId: id,
cause: "spec error: " + cause,
}
} | go | {
"resource": ""
} |
q9422 | getGicInfo | train | func getGicInfo() (info string) {
gicinfo, err := os.Open("/proc/interrupts")
if err != nil {
return "unknown"
}
defer gicinfo.Close()
scanner := bufio.NewScanner(gicinfo)
for scanner.Scan() {
newline := scanner.Text()
list := strings.Fields(newline)
for _, item := range list {
if strings.EqualFold(item, "GICv2") {
return "gicv2"
} else if strings.EqualFold(item, "GICv3") ||
strings.EqualFold(item, "GICv4") {
return "gicv3"
}
}
}
return "unknown"
} | go | {
"resource": ""
} |
q9423 | NewVmFromTemplate | train | func (t *TemplateVmConfig) NewVmFromTemplate(vmName string) (*hypervisor.Vm, error) {
return hypervisor.GetVm(vmName, t.BootConfigFromTemplate(), false)
} | go | {
"resource": ""
} |
q9424 | NewProcessList | train | func NewProcessList(root, name string) (*ProcessList, error) {
f, err := os.OpenFile(filepath.Join(root, name, processJSON), os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return nil, err
}
if err = syscall.Flock(int(f.Fd()), syscall.LOCK_SH); err != nil {
f.Close()
return nil, fmt.Errorf("Placing LOCK_SH lock on process json file failed: %s", err.Error())
}
return &ProcessList{file: f}, nil
} | go | {
"resource": ""
} |
q9425 | NewServer | train | func NewServer(address string, json agent.SandboxAgent) (*grpc.Server, error) {
s := grpc.NewServer()
jp := &jsonProxy{
json: json,
self: s,
}
kagenta.RegisterAgentServiceServer(s, jp)
healthServer := health.NewServer()
grpc_health_v1.RegisterHealthServer(s, healthServer)
return s, nil
} | go | {
"resource": ""
} |
q9426 | machineID | train | func machineID() (string, error) {
k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Cryptography`, registry.QUERY_VALUE|registry.WOW64_64KEY)
if err != nil {
return "", err
}
defer k.Close()
s, _, err := k.GetStringValue("MachineGuid")
if err != nil {
return "", err
}
return s, nil
} | go | {
"resource": ""
} |
q9427 | ProtectedID | train | func ProtectedID(appID string) (string, error) {
id, err := ID()
if err != nil {
return "", fmt.Errorf("machineid: %v", err)
}
return protect(appID, id), nil
} | go | {
"resource": ""
} |
q9428 | machineID | train | func machineID() (string, error) {
buf := &bytes.Buffer{}
err := run(buf, os.Stderr, "ioreg", "-rd1", "-c", "IOPlatformExpertDevice")
if err != nil {
return "", err
}
id, err := extractID(buf.String())
if err != nil {
return "", err
}
return trim(id), nil
} | go | {
"resource": ""
} |
q9429 | run | train | func run(stdout, stderr io.Writer, cmd string, args ...string) error {
c := exec.Command(cmd, args...)
c.Stdin = os.Stdin
c.Stdout = stdout
c.Stderr = stderr
return c.Run()
} | go | {
"resource": ""
} |
q9430 | protect | train | func protect(appID, id string) string {
mac := hmac.New(sha256.New, []byte(id))
mac.Write([]byte(appID))
return hex.EncodeToString(mac.Sum(nil))
} | go | {
"resource": ""
} |
q9431 | Headers | train | func (c *Client) Headers(method, url, timestamp, data string) (map[string]string, error) {
h := make(map[string]string)
h["CB-ACCESS-KEY"] = c.Key
h["CB-ACCESS-PASSPHRASE"] = c.Passphrase
h["CB-ACCESS-TIMESTAMP"] = timestamp
message := fmt.Sprintf(
"%s%s%s%s",
timestamp,
method,
url,
data,
)
sig, err := generateSig(message, c.Secret)
if err != nil {
return nil, err
}
h["CB-ACCESS-SIGN"] = sig
return h, nil
} | go | {
"resource": ""
} |
q9432 | NewFake | train | func NewFake(fakeMode FakeMode, targetName string, packagePath string, fakeName string, destinationPackage string, workingDir string) (*Fake, error) {
f := &Fake{
TargetName: targetName,
TargetPackage: packagePath,
Name: fakeName,
Mode: fakeMode,
DestinationPackage: destinationPackage,
Imports: newImports(),
}
f.Imports.Add("sync", "sync")
err := f.loadPackages(workingDir)
if err != nil {
return nil, err
}
// TODO: Package mode here
err = f.findPackage()
if err != nil {
return nil, err
}
if f.IsInterface() || f.Mode == Package {
f.loadMethods()
}
if f.IsFunction() {
err = f.loadMethodForFunction()
if err != nil {
return nil, err
}
}
return f, nil
} | go | {
"resource": ""
} |
q9433 | IsInterface | train | func (f *Fake) IsInterface() bool {
if f.Target == nil || f.Target.Type() == nil {
return false
}
return types.IsInterface(f.Target.Type())
} | go | {
"resource": ""
} |
q9434 | IsFunction | train | func (f *Fake) IsFunction() bool {
if f.Target == nil || f.Target.Type() == nil || f.Target.Type().Underlying() == nil {
return false
}
_, ok := f.Target.Type().Underlying().(*types.Signature)
return ok
} | go | {
"resource": ""
} |
q9435 | Generate | train | func (f *Fake) Generate(runImports bool) ([]byte, error) {
var tmpl *template.Template
if f.IsInterface() {
log.Printf("Writing fake %s for interface %s to package %s\n", f.Name, f.TargetName, f.DestinationPackage)
tmpl = template.Must(template.New("fake").Funcs(interfaceFuncs).Parse(interfaceTemplate))
}
if f.IsFunction() {
log.Printf("Writing fake %s for function %s to package %s\n", f.Name, f.TargetName, f.DestinationPackage)
tmpl = template.Must(template.New("fake").Funcs(functionFuncs).Parse(functionTemplate))
}
if f.Mode == Package {
log.Printf("Writing fake %s for package %s to package %s\n", f.Name, f.TargetPackage, f.DestinationPackage)
tmpl = template.Must(template.New("fake").Funcs(packageFuncs).Parse(packageTemplate))
}
if tmpl == nil {
return nil, errors.New("counterfeiter can only generate fakes for interfaces or specific functions")
}
b := &bytes.Buffer{}
tmpl.Execute(b, f)
if runImports {
return imports.Process("counterfeiter_temp_process_file", b.Bytes(), nil)
}
return b.Bytes(), nil
} | go | {
"resource": ""
} |
q9436 | interfaceMethodSet | train | func interfaceMethodSet(t types.Type) []*rawMethod {
if t == nil {
return nil
}
var result []*rawMethod
methods := typeutil.IntuitiveMethodSet(t, nil)
for i := range methods {
if methods[i].Obj() == nil || methods[i].Type() == nil {
continue
}
fun, ok := methods[i].Obj().(*types.Func)
if !ok {
continue
}
sig, ok := methods[i].Type().(*types.Signature)
if !ok {
continue
}
result = append(result, &rawMethod{
Func: fun,
Signature: sig,
})
}
return result
} | go | {
"resource": ""
} |
q9437 | Slices | train | func (p Params) Slices() Params {
var result Params
for i := range p {
if p[i].IsSlice {
result = append(result, p[i])
}
}
return result
} | go | {
"resource": ""
} |
q9438 | WithPrefix | train | func (p Params) WithPrefix(prefix string) string {
if len(p) == 0 {
return ""
}
params := []string{}
for i := range p {
if prefix == "" {
params = append(params, unexport(p[i].Name))
} else {
params = append(params, prefix+unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | go | {
"resource": ""
} |
q9439 | AsArgs | train | func (p Params) AsArgs() string {
if len(p) == 0 {
return ""
}
params := []string{}
for i := range p {
params = append(params, p[i].Type)
}
return strings.Join(params, ", ")
} | go | {
"resource": ""
} |
q9440 | AsNamedArgsWithTypes | train | func (p Params) AsNamedArgsWithTypes() string {
if len(p) == 0 {
return ""
}
params := []string{}
for i := range p {
params = append(params, unexport(p[i].Name)+" "+p[i].Type)
}
return strings.Join(params, ", ")
} | go | {
"resource": ""
} |
q9441 | AsNamedArgs | train | func (p Params) AsNamedArgs() string {
if len(p) == 0 {
return ""
}
params := []string{}
for i := range p {
if p[i].IsSlice {
params = append(params, unexport(p[i].Name)+"Copy")
} else {
params = append(params, unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | go | {
"resource": ""
} |
q9442 | AsNamedArgsForInvocation | train | func (p Params) AsNamedArgsForInvocation() string {
if len(p) == 0 {
return ""
}
params := []string{}
for i := range p {
if p[i].IsVariadic {
params = append(params, unexport(p[i].Name)+"...")
} else {
params = append(params, unexport(p[i].Name))
}
}
return strings.Join(params, ", ")
} | go | {
"resource": ""
} |
q9443 | AsReturnSignature | train | func (p Params) AsReturnSignature() string {
if len(p) == 0 {
return ""
}
if len(p) == 1 {
if p[0].IsVariadic {
return strings.Replace(p[0].Type, "...", "[]", -1)
}
return p[0].Type
}
result := "("
for i := range p {
t := p[i].Type
if p[i].IsVariadic {
t = strings.Replace(t, "...", "[]", -1)
}
result = result + t
if i < len(p) {
result = result + ", "
}
}
result = result + ")"
return result
} | go | {
"resource": ""
} |
q9444 | String | train | func (i Import) String() string {
if path.Base(i.PkgPath) == i.Alias {
return `"` + i.PkgPath + `"`
}
return fmt.Sprintf(`%s "%s"`, i.Alias, i.PkgPath)
} | go | {
"resource": ""
} |
q9445 | Add | train | func (i *Imports) Add(alias string, path string) Import {
path = imports.VendorlessPath(strings.TrimSpace(path))
alias = strings.TrimSpace(alias)
imp, exists := i.ByPkgPath[path]
if exists {
return imp
}
_, exists = i.ByAlias[alias]
if exists {
alias = uniqueAliasForImport(alias, i.ByAlias)
}
result := Import{Alias: alias, PkgPath: path}
i.ByPkgPath[path] = result
i.ByAlias[alias] = result
return result
} | go | {
"resource": ""
} |
q9446 | AliasForPackage | train | func (i *Imports) AliasForPackage(p *types.Package) string {
return i.ByPkgPath[imports.VendorlessPath(p.Path())].Alias
} | go | {
"resource": ""
} |
q9447 | packageMethodSet | train | func packageMethodSet(p *packages.Package) []*rawMethod {
if p == nil || p.Types == nil || p.Types.Scope() == nil {
return nil
}
var result []*rawMethod
scope := p.Types.Scope()
for _, name := range scope.Names() {
obj := scope.Lookup(name)
if !obj.Exported() {
continue // skip unexported names
}
fun, ok := obj.(*types.Func)
if !ok {
continue
}
sig, ok := obj.Type().(*types.Signature)
if !ok {
continue
}
result = append(result, &rawMethod{
Func: fun,
Signature: sig,
})
}
return result
} | go | {
"resource": ""
} |
q9448 | addImportsFor | train | func (f *Fake) addImportsFor(typ types.Type) {
if typ == nil {
return
}
switch t := typ.(type) {
case *types.Basic:
return
case *types.Pointer:
f.addImportsFor(t.Elem())
case *types.Map:
f.addImportsFor(t.Key())
f.addImportsFor(t.Elem())
case *types.Chan:
f.addImportsFor(t.Elem())
case *types.Named:
if t.Obj() != nil && t.Obj().Pkg() != nil {
f.Imports.Add(t.Obj().Pkg().Name(), t.Obj().Pkg().Path())
}
case *types.Slice:
f.addImportsFor(t.Elem())
case *types.Array:
f.addImportsFor(t.Elem())
case *types.Interface:
return
case *types.Signature:
f.addTypesForMethod(t)
default:
log.Printf("!!! WARNING: Missing case for type %s\n", reflect.TypeOf(typ).String())
}
} | go | {
"resource": ""
} |
q9449 | WithPrefix | train | func (r Returns) WithPrefix(p string) string {
if len(r) == 0 {
return ""
}
rets := []string{}
for i := range r {
if p == "" {
rets = append(rets, unexport(r[i].Name))
} else {
rets = append(rets, p+unexport(r[i].Name))
}
}
return strings.Join(rets, ", ")
} | go | {
"resource": ""
} |
q9450 | AsArgs | train | func (r Returns) AsArgs() string {
if len(r) == 0 {
return ""
}
rets := []string{}
for i := range r {
rets = append(rets, r[i].Type)
}
return strings.Join(rets, ", ")
} | go | {
"resource": ""
} |
q9451 | AsNamedArgsWithTypes | train | func (r Returns) AsNamedArgsWithTypes() string {
if len(r) == 0 {
return ""
}
rets := []string{}
for i := range r {
rets = append(rets, unexport(r[i].Name)+" "+r[i].Type)
}
return strings.Join(rets, ", ")
} | go | {
"resource": ""
} |
q9452 | AsNamedArgs | train | func (r Returns) AsNamedArgs() string {
if len(r) == 0 {
return ""
}
rets := []string{}
for i := range r {
rets = append(rets, unexport(r[i].Name))
}
return strings.Join(rets, ", ")
} | go | {
"resource": ""
} |
q9453 | AsReturnSignature | train | func (r Returns) AsReturnSignature() string {
if len(r) == 0 {
return ""
}
if len(r) == 1 {
return r[0].Type
}
result := "("
for i := range r {
result = result + r[i].Type
if i < len(r) {
result = result + ", "
}
}
result = result + ")"
return result
} | go | {
"resource": ""
} |
q9454 | NewKeyBook | train | func NewKeyBook() pstore.KeyBook {
return &memoryKeyBook{
pks: map[peer.ID]ic.PubKey{},
sks: map[peer.ID]ic.PrivKey{},
}
} | go | {
"resource": ""
} |
q9455 | NewPeerstore | train | func NewPeerstore(ctx context.Context, store ds.Batching, opts Options) (pstore.Peerstore, error) {
addrBook, err := NewAddrBook(ctx, store, opts)
if err != nil {
return nil, err
}
keyBook, err := NewKeyBook(ctx, store, opts)
if err != nil {
return nil, err
}
peerMetadata, err := NewPeerMetadata(ctx, store, opts)
if err != nil {
return nil, err
}
ps := pstore.NewPeerstore(keyBook, addrBook, peerMetadata)
return ps, nil
} | go | {
"resource": ""
} |
q9456 | uniquePeerIds | train | func uniquePeerIds(ds ds.Datastore, prefix ds.Key, extractor func(result query.Result) string) (peer.IDSlice, error) {
var (
q = query.Query{Prefix: prefix.String(), KeysOnly: true}
results query.Results
err error
)
if results, err = ds.Query(q); err != nil {
log.Error(err)
return nil, err
}
defer results.Close()
idset := make(map[string]struct{})
for result := range results.Next() {
k := extractor(result)
idset[k] = struct{}{}
}
if len(idset) == 0 {
return peer.IDSlice{}, nil
}
ids := make(peer.IDSlice, 0, len(idset))
for id := range idset {
pid, _ := base32.RawStdEncoding.DecodeString(id)
id, _ := peer.IDFromBytes(pid)
ids = append(ids, id)
}
return ids, nil
} | go | {
"resource": ""
} |
q9457 | RecordLatency | train | func (m *metrics) RecordLatency(p peer.ID, next time.Duration) {
nextf := float64(next)
s := LatencyEWMASmoothing
if s > 1 || s < 0 {
s = 0.1 // ignore the knob. it's broken. look, it jiggles.
}
m.latmu.Lock()
ewma, found := m.latmap[p]
ewmaf := float64(ewma)
if !found {
m.latmap[p] = next // when no data, just take it as the mean.
} else {
nextf = ((1.0 - s) * ewmaf) + (s * nextf)
m.latmap[p] = time.Duration(nextf)
}
m.latmu.Unlock()
} | go | {
"resource": ""
} |
q9458 | LatencyEWMA | train | func (m *metrics) LatencyEWMA(p peer.ID) time.Duration {
m.latmu.RLock()
lat := m.latmap[p]
m.latmu.RUnlock()
return time.Duration(lat)
} | go | {
"resource": ""
} |
q9459 | NewPopulatedProtoAddr | train | func NewPopulatedProtoAddr(r randyPstore) *ProtoAddr {
a, _ := ma.NewMultiaddr("/ip4/123.123.123.123/tcp/7001")
return &ProtoAddr{Multiaddr: a}
} | go | {
"resource": ""
} |
q9460 | NewPopulatedProtoPeerID | train | func NewPopulatedProtoPeerID(r randyPstore) *ProtoPeerID {
id, _ := pt.RandPeerID()
return &ProtoPeerID{ID: id}
} | go | {
"resource": ""
} |
q9461 | background | train | func (mab *memoryAddrBook) background() {
ticker := time.NewTicker(1 * time.Hour)
defer ticker.Stop()
for {
select {
case <-ticker.C:
mab.gc()
case <-mab.ctx.Done():
return
}
}
} | go | {
"resource": ""
} |
q9462 | gc | train | func (mab *memoryAddrBook) gc() {
mab.addrmu.Lock()
defer mab.addrmu.Unlock()
now := time.Now()
for p, amap := range mab.addrs {
for k, addr := range amap {
if addr.ExpiredBy(now) {
delete(amap, k)
}
}
if len(amap) == 0 {
delete(mab.addrs, p)
}
}
} | go | {
"resource": ""
} |
q9463 | UpdateAddrs | train | func (mab *memoryAddrBook) UpdateAddrs(p peer.ID, oldTTL time.Duration, newTTL time.Duration) {
mab.addrmu.Lock()
defer mab.addrmu.Unlock()
amap, found := mab.addrs[p]
if !found {
return
}
exp := time.Now().Add(newTTL)
for k, addr := range amap {
if oldTTL == addr.TTL {
addr.TTL = newTTL
addr.Expires = exp
amap[k] = addr
}
}
} | go | {
"resource": ""
} |
q9464 | ClearAddrs | train | func (mab *memoryAddrBook) ClearAddrs(p peer.ID) {
mab.addrmu.Lock()
defer mab.addrmu.Unlock()
delete(mab.addrs, p)
} | go | {
"resource": ""
} |
q9465 | removeSub | train | func (mgr *AddrSubManager) removeSub(p peer.ID, s *addrSub) {
mgr.mu.Lock()
defer mgr.mu.Unlock()
subs := mgr.subs[p]
if len(subs) == 1 {
if subs[0] != s {
return
}
delete(mgr.subs, p)
return
}
for i, v := range subs {
if v == s {
subs[i] = subs[len(subs)-1]
subs[len(subs)-1] = nil
mgr.subs[p] = subs[:len(subs)-1]
return
}
}
} | go | {
"resource": ""
} |
q9466 | BroadcastAddr | train | func (mgr *AddrSubManager) BroadcastAddr(p peer.ID, addr ma.Multiaddr) {
mgr.mu.RLock()
defer mgr.mu.RUnlock()
if subs, ok := mgr.subs[p]; ok {
for _, sub := range subs {
sub.pubAddr(addr)
}
}
} | go | {
"resource": ""
} |
q9467 | AddrStream | train | func (mgr *AddrSubManager) AddrStream(ctx context.Context, p peer.ID, initial []ma.Multiaddr) <-chan ma.Multiaddr {
sub := &addrSub{pubch: make(chan ma.Multiaddr), ctx: ctx}
out := make(chan ma.Multiaddr)
mgr.mu.Lock()
if _, ok := mgr.subs[p]; ok {
mgr.subs[p] = append(mgr.subs[p], sub)
} else {
mgr.subs[p] = []*addrSub{sub}
}
mgr.mu.Unlock()
sort.Sort(addr.AddrList(initial))
go func(buffer []ma.Multiaddr) {
defer close(out)
sent := make(map[string]bool, len(buffer))
var outch chan ma.Multiaddr
for _, a := range buffer {
sent[string(a.Bytes())] = true
}
var next ma.Multiaddr
if len(buffer) > 0 {
next = buffer[0]
buffer = buffer[1:]
outch = out
}
for {
select {
case outch <- next:
if len(buffer) > 0 {
next = buffer[0]
buffer = buffer[1:]
} else {
outch = nil
next = nil
}
case naddr := <-sub.pubch:
if sent[string(naddr.Bytes())] {
continue
}
sent[string(naddr.Bytes())] = true
if next == nil {
next = naddr
outch = out
} else {
buffer = append(buffer, naddr)
}
case <-ctx.Done():
mgr.removeSub(p, sub)
return
}
}
}(initial)
return out
} | go | {
"resource": ""
} |
q9468 | NewPeerstore | train | func NewPeerstore(kb KeyBook, ab AddrBook, md PeerMetadata) Peerstore {
return &peerstore{
KeyBook: kb,
AddrBook: ab,
PeerMetadata: md,
Metrics: NewMetrics(),
internedProtocols: make(map[string]string),
}
} | go | {
"resource": ""
} |
q9469 | background | train | func (gc *dsAddrBookGc) background() {
defer gc.ab.childrenDone.Done()
select {
case <-time.After(gc.ab.opts.GCInitialDelay):
case <-gc.ab.ctx.Done():
// yield if we have been cancelled/closed before the delay elapses.
return
}
purgeTimer := time.NewTicker(gc.ab.opts.GCPurgeInterval)
defer purgeTimer.Stop()
var lookaheadCh <-chan time.Time
if gc.lookaheadEnabled {
lookaheadTimer := time.NewTicker(gc.ab.opts.GCLookaheadInterval)
lookaheadCh = lookaheadTimer.C
gc.populateLookahead() // do a lookahead now
defer lookaheadTimer.Stop()
}
for {
select {
case <-purgeTimer.C:
gc.purgeFunc()
case <-lookaheadCh:
// will never trigger if lookahead is disabled (nil Duration).
gc.populateLookahead()
case <-gc.ctx.Done():
return
}
}
} | go | {
"resource": ""
} |
q9470 | flush | train | func (r *addrsRecord) flush(write ds.Write) (err error) {
key := addrBookBase.ChildString(b32.RawStdEncoding.EncodeToString([]byte(r.Id.ID)))
if len(r.Addrs) == 0 {
if err = write.Delete(key); err == nil {
r.dirty = false
}
return err
}
data, err := r.Marshal()
if err != nil {
return err
}
if err = write.Put(key, data); err != nil {
return err
}
// write succeeded; record is no longer dirty.
r.dirty = false
return nil
} | go | {
"resource": ""
} |
q9471 | AddAddr | train | func (ab *dsAddrBook) AddAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration) {
ab.AddAddrs(p, []ma.Multiaddr{addr}, ttl)
} | go | {
"resource": ""
} |
q9472 | AddAddrs | train | func (ab *dsAddrBook) AddAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration) {
if ttl <= 0 {
return
}
addrs = cleanAddrs(addrs)
ab.setAddrs(p, addrs, ttl, ttlExtend)
} | go | {
"resource": ""
} |
q9473 | SetAddr | train | func (ab *dsAddrBook) SetAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration) {
ab.SetAddrs(p, []ma.Multiaddr{addr}, ttl)
} | go | {
"resource": ""
} |
q9474 | SetAddrs | train | func (ab *dsAddrBook) SetAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration) {
addrs = cleanAddrs(addrs)
if ttl <= 0 {
ab.deleteAddrs(p, addrs)
return
}
ab.setAddrs(p, addrs, ttl, ttlOverride)
} | go | {
"resource": ""
} |
q9475 | UpdateAddrs | train | func (ab *dsAddrBook) UpdateAddrs(p peer.ID, oldTTL time.Duration, newTTL time.Duration) {
pr, err := ab.loadRecord(p, true, false)
if err != nil {
log.Errorf("failed to update ttls for peer %s: %s\n", p.Pretty(), err)
return
}
pr.Lock()
defer pr.Unlock()
newExp := time.Now().Add(newTTL).Unix()
for _, entry := range pr.Addrs {
if entry.Ttl != int64(oldTTL) {
continue
}
entry.Ttl, entry.Expiry = int64(newTTL), newExp
pr.dirty = true
}
if pr.clean() {
pr.flush(ab.ds)
}
} | go | {
"resource": ""
} |
q9476 | Addrs | train | func (ab *dsAddrBook) Addrs(p peer.ID) []ma.Multiaddr {
pr, err := ab.loadRecord(p, true, true)
if err != nil {
log.Warning("failed to load peerstore entry for peer %v while querying addrs, err: %v", p, err)
return nil
}
pr.RLock()
defer pr.RUnlock()
addrs := make([]ma.Multiaddr, 0, len(pr.Addrs))
for _, a := range pr.Addrs {
addrs = append(addrs, a.Addr)
}
return addrs
} | go | {
"resource": ""
} |
q9477 | PeersWithAddrs | train | func (ab *dsAddrBook) PeersWithAddrs() peer.IDSlice {
ids, err := uniquePeerIds(ab.ds, addrBookBase, func(result query.Result) string {
return ds.RawKey(result.Key).Name()
})
if err != nil {
log.Errorf("error while retrieving peers with addresses: %v", err)
}
return ids
} | go | {
"resource": ""
} |
q9478 | ClearAddrs | train | func (ab *dsAddrBook) ClearAddrs(p peer.ID) {
ab.cache.Remove(p)
key := addrBookBase.ChildString(b32.RawStdEncoding.EncodeToString([]byte(p)))
if err := ab.ds.Delete(key); err != nil {
log.Errorf("failed to clear addresses for peer %s: %v", p.Pretty(), err)
}
} | go | {
"resource": ""
} |
q9479 | NewChanQueue | train | func NewChanQueue(ctx context.Context, pq PeerQueue) *ChanQueue {
cq := &ChanQueue{Queue: pq}
cq.process(ctx)
return cq
} | go | {
"resource": ""
} |
q9480 | AddQueryParameters | train | func AddQueryParameters(baseURL string, queryParams map[string]string) string {
baseURL += "?"
params := url.Values{}
for key, value := range queryParams {
params.Add(key, value)
}
return baseURL + params.Encode()
} | go | {
"resource": ""
} |
q9481 | BuildRequestObject | train | func BuildRequestObject(request Request) (*http.Request, error) {
// Add any query parameters to the URL.
if len(request.QueryParams) != 0 {
request.BaseURL = AddQueryParameters(request.BaseURL, request.QueryParams)
}
req, err := http.NewRequest(string(request.Method), request.BaseURL, bytes.NewBuffer(request.Body))
if err != nil {
return req, err
}
for key, value := range request.Headers {
req.Header.Set(key, value)
}
_, exists := req.Header["Content-Type"]
if len(request.Body) > 0 && !exists {
req.Header.Set("Content-Type", "application/json")
}
return req, err
} | go | {
"resource": ""
} |
q9482 | MakeRequest | train | func MakeRequest(req *http.Request) (*http.Response, error) {
return DefaultClient.HTTPClient.Do(req)
} | go | {
"resource": ""
} |
q9483 | BuildResponse | train | func BuildResponse(res *http.Response) (*Response, error) {
body, err := ioutil.ReadAll(res.Body)
response := Response{
StatusCode: res.StatusCode,
Body: string(body),
Headers: res.Header,
}
res.Body.Close() // nolint
return &response, err
} | go | {
"resource": ""
} |
q9484 | MakeRequest | train | func (c *Client) MakeRequest(req *http.Request) (*http.Response, error) {
return c.HTTPClient.Do(req)
} | go | {
"resource": ""
} |
q9485 | Send | train | func (c *Client) Send(request Request) (*Response, error) {
// Build the HTTP request object.
req, err := BuildRequestObject(request)
if err != nil {
return nil, err
}
// Build the HTTP client and make the request.
res, err := c.MakeRequest(req)
if err != nil {
return nil, err
}
// Build Response object.
return BuildResponse(res)
} | go | {
"resource": ""
} |
q9486 | Parse | train | func (p *Parser) Parse(text string, base time.Time) (*Result, error) {
res := Result{
Source: text,
Time: base,
Index: -1,
}
if p.options == nil {
p.options = defaultOptions
}
var err error
// apply middlewares
for _, b := range p.middleware {
text, err = b(text)
if err != nil {
return nil, err
}
}
// find all matches
matches := make([]*rules.Match, 0)
c := float64(0)
for _, rule := range p.rules {
r := rule.Find(text)
if r != nil {
r.Order = c
c++
matches = append(matches, r)
}
}
// not found
if len(matches) == 0 {
return nil, nil
}
// find a cluster
sort.Sort(rules.MatchByIndex(matches))
// get borders of the matches
end := matches[0].Right
res.Index = matches[0].Left
for i, m := range matches {
if m.Left <= end+p.options.Distance {
end = m.Right
} else {
matches = matches[:i]
break
}
}
res.Text = text[res.Index:end]
// apply rules
if p.options.MatchByOrder {
sort.Sort(rules.MatchByOrder(matches))
}
ctx := &rules.Context{Text: res.Text}
applied := false
for _, applier := range matches {
ok, err := applier.Apply(ctx, p.options, res.Time)
if err != nil {
return nil, err
}
applied = ok || applied
}
if !applied {
return nil, nil
}
res.Time, err = ctx.Time(res.Time)
if err != nil {
return nil, errors.Wrap(err, "bind context")
}
return &res, nil
} | go | {
"resource": ""
} |
q9487 | Add | train | func (p *Parser) Add(r ...rules.Rule) {
p.rules = append(p.rules, r...)
} | go | {
"resource": ""
} |
q9488 | Use | train | func (p *Parser) Use(f ...func(string) (string, error)) {
p.middleware = append(p.middleware, f...)
} | go | {
"resource": ""
} |
q9489 | New | train | func New(o *rules.Options) *Parser {
if o == nil {
return &Parser{options: defaultOptions}
}
return &Parser{options: o}
} | go | {
"resource": ""
} |
q9490 | NewBreakerWithOptions | train | func NewBreakerWithOptions(options *Options) *Breaker {
if options == nil {
options = &Options{}
}
if options.Clock == nil {
options.Clock = clock.New()
}
if options.BackOff == nil {
b := backoff.NewExponentialBackOff()
b.InitialInterval = defaultInitialBackOffInterval
b.MaxElapsedTime = defaultBackoffMaxElapsedTime
b.Clock = options.Clock
b.Reset()
options.BackOff = b
}
if options.WindowTime == 0 {
options.WindowTime = DefaultWindowTime
}
if options.WindowBuckets == 0 {
options.WindowBuckets = DefaultWindowBuckets
}
return &Breaker{
BackOff: options.BackOff,
Clock: options.Clock,
ShouldTrip: options.ShouldTrip,
nextBackOff: options.BackOff.NextBackOff(),
counts: newWindow(options.WindowTime, options.WindowBuckets),
}
} | go | {
"resource": ""
} |
q9491 | NewRateBreaker | train | func NewRateBreaker(rate float64, minSamples int64) *Breaker {
return NewBreakerWithOptions(&Options{
ShouldTrip: RateTripFunc(rate, minSamples),
})
} | go | {
"resource": ""
} |
q9492 | Subscribe | train | func (cb *Breaker) Subscribe() <-chan BreakerEvent {
eventReader := make(chan BreakerEvent)
output := make(chan BreakerEvent, 100)
go func() {
for v := range eventReader {
select {
case output <- v:
default:
<-output
output <- v
}
}
}()
cb.eventReceivers = append(cb.eventReceivers, eventReader)
return output
} | go | {
"resource": ""
} |
q9493 | AddListener | train | func (cb *Breaker) AddListener(listener chan ListenerEvent) {
cb.listeners = append(cb.listeners, listener)
} | go | {
"resource": ""
} |
q9494 | RemoveListener | train | func (cb *Breaker) RemoveListener(listener chan ListenerEvent) bool {
for i, receiver := range cb.listeners {
if listener == receiver {
cb.listeners = append(cb.listeners[:i], cb.listeners[i+1:]...)
return true
}
}
return false
} | go | {
"resource": ""
} |
q9495 | ResetCounters | train | func (cb *Breaker) ResetCounters() {
atomic.StoreInt64(&cb.consecFailures, 0)
cb.counts.Reset()
} | go | {
"resource": ""
} |
q9496 | Fail | train | func (cb *Breaker) Fail() {
cb.counts.Fail()
atomic.AddInt64(&cb.consecFailures, 1)
now := cb.Clock.Now()
atomic.StoreInt64(&cb.lastFailure, now.UnixNano())
cb.sendEvent(BreakerFail)
if cb.ShouldTrip != nil && cb.ShouldTrip(cb) {
cb.Trip()
}
} | go | {
"resource": ""
} |
q9497 | Ready | train | func (cb *Breaker) Ready() bool {
state := cb.state()
if state == halfopen {
atomic.StoreInt64(&cb.halfOpens, 0)
cb.sendEvent(BreakerReady)
}
return state == closed || state == halfopen
} | go | {
"resource": ""
} |
q9498 | Call | train | func (cb *Breaker) Call(circuit func() error, timeout time.Duration) error {
return cb.CallContext(context.Background(), circuit, timeout)
} | go | {
"resource": ""
} |
q9499 | CallContext | train | func (cb *Breaker) CallContext(ctx context.Context, circuit func() error, timeout time.Duration) error {
var err error
if !cb.Ready() {
return ErrBreakerOpen
}
if timeout == 0 {
err = circuit()
} else {
c := make(chan error, 1)
go func() {
c <- circuit()
close(c)
}()
select {
case e := <-c:
err = e
case <-cb.Clock.After(timeout):
err = ErrBreakerTimeout
}
}
if err != nil {
if ctx.Err() != context.Canceled {
cb.Fail()
}
return err
}
cb.Success()
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.