id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c22300 | codelocation.New(1), parseTimeout(timeout...))
return true
} | |
c22301 | codelocation.New(1), parseTimeout(timeout...))
return true
} | |
c22302 | types.FlagTypePending, codelocation.New(1), 0)
return true
} | |
c22303 | types.FlagTypePending, codelocation.New(1), 0)
return true
} | |
c22304 | body, types.FlagTypeFocused, codelocation.New(1), samples)
return true
} | |
c22305 | func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
return true
} | |
c22306 | codelocation.New(1), parseTimeout(timeout...))
return true
} | |
c22307 | codelocation.New(1), parseTimeout(timeout...))
return true
} | |
c22308 | if err != nil {
return types.InternalErrorf("macvlan driver failed to initialize data store: %v", err)
}
return d.populateNetworks()
}
return nil
} | |
c22309 | kvol {
config := kvo.(*configuration)
if err = d.createNetwork(config); err != nil {
logrus.Warnf("Could not create macvlan network for id %s from persistent state", config.ID)
}
}
return nil
} | |
c22310 |
// disallow port exposure --expose
if opt, ok := epOptions[netlabel.ExposedPorts]; ok {
if _, ok := opt.([]types.TransportPort); ok {
if len(opt.([]types.TransportPort)) > 0 {
logrus.Warnf("%s driver does not support port exposures", ipvlanType)
}
}
}
if err := d.storeUpdate(ep); err != nil {
retu... | |
c22311 | not found", eid)
}
if link, err := ns.NlHandle().LinkByName(ep.srcName); err == nil {
if err := ns.NlHandle().LinkDel(link); err != nil {
logrus.WithError(err).Warnf("Failed to delete interface (%s)'s link on endpoint (%s) delete", ep.srcName, ep.id)
}
}
if err := d.storeDelete(ep); err != nil {
logrus.W... | |
c22312 | {
logrus.WithError(err).Errorf("error setting the kernel parameter %s = %s, (leaving as %s)", k, v.Value, oldv)
continue
}
logrus.Debugf("updated kernel parameter %s = %s (was %s)", k, v.Value, oldv)
}
}
} | |
c22313 | ordinal, err := i.handle.SetAny(serial)
return i.start + ordinal, err
} | |
c22314 |
}
if id < i.start || id > i.end {
return errors.New("Requested id does not belong to the set")
}
return i.handle.Set(id - i.start)
} | |
c22315 | i.handle.Unset(id - i.start)
} | |
c22316 | t.Proto != o.Proto || t.Port != o.Port {
return false
}
return true
} | |
c22317 | {
return TransportPort{Proto: t.Proto, Port: t.Port}
} | |
c22318 | {
return fmt.Sprintf("%s/%d", t.Proto.String(), t.Port)
} | |
c22319 | uint16(p)
return nil
}
}
return BadRequestErrorf("invalid format for transport port: %s", s)
} | |
c22320 | return &net.TCPAddr{IP: p.HostIP, Port: int(p.HostPort)}, nil
case SCTP:
return &sctp.SCTPAddr{IP: []net.IP{p.HostIP}, Port: int(p.HostPort)}, nil
default:
return nil, ErrInvalidProtocolBinding(p.Proto.String())
}
} | |
c22321 | p.Port,
HostIP: GetIPCopy(p.HostIP),
HostPort: p.HostPort,
HostPortEnd: p.HostPortEnd,
}
} | |
c22322 | }
ret = fmt.Sprintf("%s:%d/", ret, p.Port)
if p.HostIP != nil {
ret += p.HostIP.String()
}
ret = fmt.Sprintf("%s:%d", ret, p.HostPort)
return ret
} | |
c22323 | o.IP != nil {
return false
}
}
if p.HostIP != nil {
if !p.HostIP.Equal(o.HostIP) {
return false
}
} else {
if o.HostIP != nil {
return false
}
}
return true
} | |
c22324 | return ICMP
case "udp":
return UDP
case "tcp":
return TCP
case "sctp":
return SCTP
default:
return 0
}
} | |
c22325 |
to := make(net.HardwareAddr, len(from))
copy(to, from)
return to
} | |
c22326 | := make(net.IP, len(from))
copy(to, from)
return to
} | |
c22327 | from.Mask)
return &net.IPNet{IP: GetIPCopy(from.IP), Mask: bm}
} | |
c22328 |
c := GetIPNetCopy(nw)
c.IP = c.IP.Mask(nw.Mask)
return c
} | |
c22329 | return a.IP.Equal(b.IP) && bytes.Equal(a.Mask, b.Mask)
} | |
c22330 | return ip.To4()
}
return ip
} | |
c22331 |
m = m[12:16]
}
return &net.IPNet{IP: nw.IP.To4(), Mask: m}
}
return nw
} | |
c22332 | // Check if address and mask are semantically compatible
if len(ip[is:]) != len(mask[ms:]) {
err = fmt.Errorf("ip and mask are not compatible: (%#v, %#v)", ip, mask)
}
return
} | |
c22333 | }
// Compute host portion
out := GetIPCopy(ip)
for i := 0; i < len(mask[ms:]); i++ {
out[is+i] &= ^mask[ms+i]
}
return out, nil
} | |
c22334 |
return &StaticRoute{Destination: d,
RouteType: r.RouteType,
NextHop: nh,
}
} | |
c22335 | notFound(fmt.Sprintf(format, params...))
} | |
c22336 | forbidden(fmt.Sprintf(format, params...))
} | |
c22337 | noService(fmt.Sprintf(format, params...))
} | |
c22338 | notImpl(fmt.Sprintf(format, params...))
} | |
c22339 | timeout(fmt.Sprintf(format, params...))
} | |
c22340 | internal(fmt.Sprintf(format, params...))
} | |
c22341 | maskInternal(fmt.Sprintf(format, params...))
} | |
c22342 | retry(fmt.Sprintf(format, params...))
} | |
c22343 | range d.networks {
ls = append(ls, nw)
}
return ls
} | |
c22344 | if _, ok := c.Scopes[k]; !ok {
c.Scopes[k] = v
}
}
} | |
c22345 |
cfg.ProcessOptions(cfgOptions...)
cfg.LoadDefaultScopes(cfg.Daemon.DataDir)
return cfg
} | |
c22346 |
logrus.Debugf("Option DefaultNetwork: %s", dn)
c.Daemon.DefaultNetwork = strings.TrimSpace(dn)
}
} | |
c22347 | c.Daemon.DefaultDriver = strings.TrimSpace(dd)
}
} | |
c22348 | Option {
return func(c *Config) {
c.Daemon.DefaultAddressPool = addressPool
}
} | |
c22349 | Option {
return func(c *Config) {
c.Daemon.DriverCfg[networkType] = config
}
} | |
c22350 | {
c.Daemon.Labels = append(c.Daemon.Labels, label)
}
}
}
} | |
c22351 | c.Scopes[datastore.GlobalScope] = &datastore.ScopeCfg{}
}
c.Scopes[datastore.GlobalScope].Client.Provider = strings.TrimSpace(provider)
}
} | |
c22352 | c.Scopes[datastore.GlobalScope] = &datastore.ScopeCfg{}
}
c.Scopes[datastore.GlobalScope].Client.Address = strings.TrimSpace(url)
}
} | |
c22353 | nil {
c.Scopes[datastore.GlobalScope].Client.Config = &store.Config{TLS: tlsConfig}
} else {
c.Scopes[datastore.GlobalScope].Client.Config.TLS = tlsConfig
}
// Workaround libkv/etcd bug for https
c.Scopes[datastore.GlobalScope].Client.Config.ClientTLS = &store.ClientTLSConfig{
CACertFile: opts[... | |
c22354 | func(c *Config) {
c.Cluster.Watcher = watcher
}
} | |
c22355 | {
return func(c *Config) {
c.Cluster.Address = address
}
} | |
c22356 | {
return func(c *Config) {
c.Daemon.DataDir = dataDir
}
} | |
c22357 | c.Daemon.ExecRoot = execRoot
osl.SetBasePath(execRoot)
}
} | |
c22358 | func(c *Config) {
c.PluginGetter = pg
}
} | |
c22359 | Experimental: %v", exp)
c.Daemon.Experimental = exp
}
} | |
c22360 | " defaulting to minimum value (%d)", exp, minimumNetworkControlPlaneMTU)
if exp < minimumNetworkControlPlaneMTU {
exp = minimumNetworkControlPlaneMTU
}
}
c.Daemon.NetworkControlPlaneMTU = exp
}
} | |
c22361 |
if opt != nil {
opt(c)
}
}
} | |
c22362 | !ok {
c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{}
}
c.Scopes[datastore.LocalScope].Client.Config = config
}
} | |
c22363 | system bus: %v", err)
}
firewalldRunning = checkRunning()
if !firewalldRunning {
connection.sysconn.Close()
connection = nil
}
if connection != nil {
go signalHandler()
}
return nil
} | |
c22364 |
rule = fmt.Sprintf("type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged',path='/org/freedesktop/DBus',sender='org.freedesktop.DBus',arg0='%s'",
dbusInterface)
c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, rule)
c.signal = make(chan *dbus.Signal, 10)
c.sysconn.Signal(c.signa... | |
c22365 |
if pf == &callback {
return
}
}
onReloaded = append(onReloaded, &callback)
} | |
c22366 | = connection.sysobj.Call(dbusInterface+".getDefaultZone", 0).Store(&zone)
return err == nil
}
return false
} | |
c22367 | if s.subnetIP.Contains(ip) {
return true
}
}
return false
} | |
c22368 | := ip.Mask.Size()
if i != j {
continue
}
if s.subnetIP.IP.Equal(ip.IP) {
return s
}
}
return nil
} | |
c22369 | fmt.Sprintf("Sub: %s, range [%d, %d]", r.Sub, r.Start, r.End)
} | |
c22370 | r.Start,
"End": r.End,
}
return json.Marshal(m)
} | |
c22371 |
return err
}
r.Start = uint64(m["Start"].(float64))
r.End = uint64(m["End"].(float64))
return nil
} | |
c22372 | k = fmt.Sprintf("%s/%s", k, s.ChildSubnet)
}
return k
} | |
c22373 | subnetkey: %s", str)
}
s.AddressSpace = p[0]
s.Subnet = fmt.Sprintf("%s/%s", p[1], p[2])
if len(p) == 5 {
s.ChildSubnet = fmt.Sprintf("%s/%s", p[3], p[4])
}
return nil
} | |
c22374 | p.ParentKey.String(), p.Pool.String(), p.Range, p.RefCount)
} | |
c22375 | "RefCount": p.RefCount,
}
if p.Pool != nil {
m["Pool"] = p.Pool.String()
}
if p.Range != nil {
m["Range"] = p.Range
}
return json.Marshal(m)
} | |
c22376 | int
}
)
if err = json.Unmarshal(data, &t); err != nil {
return err
}
p.ParentKey = t.ParentKey
p.Range = t.Range
p.RefCount = t.RefCount
if t.Pool != "" {
if p.Pool, err = types.ParseCIDR(t.Pool); err != nil {
return err
}
}
return nil
} | |
c22377 | k, v := range aSpace.subnets {
s[k.String()] = v
}
m["Subnets"] = s
}
return json.Marshal(m)
} | |
c22378 | s == string(datastore.GlobalScope) {
aSpace.scope = datastore.GlobalScope
}
if v, ok := m["Subnets"]; ok {
sb, _ := json.Marshal(v)
var s map[string]*PoolData
err := json.Unmarshal(sb, &s)
if err != nil {
return err
}
for ks, v := range s {
k := SubnetKey{}
k.FromString(ks)
aSpace.subnets[... | |
c22379 | dstP.Range.Sub = types.GetIPNetCopy(p.Range.Sub)
dstP.Range.Start = p.Range.Start
dstP.Range.End = p.Range.End
}
dstP.RefCount = p.RefCount
return nil
} | |
c22380 | ParentKey: SubnetKey{AddressSpace: k.AddressSpace, Subnet: k.Subnet},
Pool: nw,
Range: ipr,
RefCount: 1,
}
aSpace.subnets[k] = p
// Look for parent pool
pp, ok := aSpace.subnets[p.ParentKey]
if ok {
aSpace.incRefCount(pp, 1)
return func() error { return nil }, nil
}
// Parent pool does not... | |
c22381 | if space == k.AddressSpace && k.ChildSubnet == "" {
if nw.Contains(v.Pool.IP) || v.Pool.Contains(nw.IP) {
return true
}
}
}
return false
} | |
c22382 | {
return &StubProxy{
frontendAddr: frontendAddr,
backendAddr: backendAddr,
}, nil
} | |
c22383 | := range networks {
if network.Dst != nil && NetworkOverlaps(toCheck, network.Dst) {
return ErrNetworkOverlaps
}
}
return nil
} | |
c22384 | GenerateRandomName(prefix, len)
if err != nil {
continue
}
_, err = linkByName(name)
if err != nil {
if strings.Contains(err.Error(), "not found") {
return name, nil
}
return "", err
}
}
return "", types.InternalErrorf("could not generate interface name")
} | |
c22385 | providing a
// channel to be notified on completion
waitGC := make(chan struct{})
gpmChan <- waitGC
// wait for GC completion
<-waitGC
} | |
c22386 | != nil {
logrus.Warnf("Failed to set the timeout on the sandbox netlink handle sockets: %v", err)
}
// As starting point, disable IPv6 on all interfaces
err = setIPv6(n.path, "all", false)
if err != nil {
logrus.Warnf("Failed to disable IPv6 on all interfaces on network namespace %q: %v", n.path, err)
}
if... | |
c22387 | := ns.SetNamespace(); err != nil {
logrus.Error(err)
}
return runtime.UnlockOSThread
} | |
c22388 | case SandboxTypeLoadBalancer:
kernel.ApplyOSTweaks(loadBalancerConfig)
}
}
} | |
c22389 | key {
return false
}
return true
})
}
ch := events.NewChannel(0)
sink := events.Sink(events.NewQueue(ch))
if matcher != nil {
sink = events.NewFilter(sink, matcher)
}
nDB.broadcaster.Add(sink)
return ch, func() {
nDB.broadcaster.Remove(sink)
ch.Close()
sink.Close()
}
} | |
c22390 | err != nil {
log.Printf("Stopping proxy on tcp/%v for tcp/%v (%s)", proxy.frontendAddr, proxy.backendAddr, err)
return
}
go proxy.clientLoop(client.(*net.TCPConn), quit)
}
} | |
c22391 | json.Unmarshal(value, h)
} | |
c22392 |
defer h.Unlock()
return &Handle{
app: h.app,
store: h.store,
}
} | |
c22393 |
dstH.dbIndex = h.dbIndex
dstH.dbExists = h.dbExists
dstH.store = h.store
dstH.curr = h.curr
dstH.Unlock()
return nil
} | |
c22394 | the master index (Example: the docker host eth iface)
parentLink, err := ns.NlHandle().LinkByName(parent)
if err != nil {
return "", fmt.Errorf("error occurred looking up the %s parent iface %s error: %s", ipvlanType, parent, err)
}
// Create an ipvlan link
ipvlan := &netlink.IPVlan{
LinkAttrs: netlink.LinkAt... | |
c22395 | nil
default:
return 0, fmt.Errorf("Unknown ipvlan mode: %s", mode)
}
} | |
c22396 |
if err != nil {
return false
}
return true
} | |
c22397 | return fmt.Errorf("failed to create %s vlan link: %v", vlanLink.Name, err)
}
// Bring the new netlink iface up
if err := ns.NlHandle().LinkSetUp(vlanLink); err != nil {
return fmt.Errorf("failed to enable %s the ipvlan parent link %v", vlanLink.Name, err)
}
logrus.Debugf("Added a vlan tagged netlink subin... | |
c22398 |
parentDummyLink, err := ns.NlHandle().LinkByName(dummyName)
if err != nil {
return fmt.Errorf("error occurred looking up the %s parent iface %s error: %s", ipvlanType, dummyName, err)
}
// bring the new netlink iface up
if err := ns.NlHandle().LinkSetUp(parentDummyLink); err != nil {
return fmt.Errorf("failed... | |
c22399 | deleted
if dummyLink.Attrs().ParentIndex != 0 {
return fmt.Errorf("link %s is not a parent dummy interface", linkName)
}
// delete the ipvlan dummy device
if err := ns.NlHandle().LinkDel(dummyLink); err != nil {
return fmt.Errorf("failed to delete the dummy %s link: %v", linkName, err)
}
logrus.Debugf("Delet... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.