id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c8200 | epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epO... | |
c8201 | NetworkUpdate: %+v, params: %+v", network, params)
return core.Errorf("Cant change network parameters after its created")
} | |
c8202 |
}
log.Infof("No docknet state for %s.%s. (retval = %s)",
network.TenantName, network.NetworkName, err.Error())
}
// Remove link
modeldb.RemoveLinkSet(&tenant.LinkSets.Networks, network)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Delete the net... | |
c8203 | modeldb.AddLink(&netProfile.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.NetProfiles, netProfile)
// Save the tenant in etcd - This writes to etcd.
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
return nil
} | |
c8204 | return core.Errorf("EndpointGroups not found")
}
err := master.UpdateEndpointGroup(params.Bandwidth, epg.GroupName, epg.TenantName, params.DSCP, params.Burst)
if err != nil {
log.Errorf("Error updating the EndpointGroups: %s. Err: %v", epg.GroupName, err)
}
}
return nil
} | |
c8205 | if any endpoint group is using the network policy
if len(netProfile.LinkSets.EndpointGroups) != 0 {
return core.Errorf("NetProfile is being used")
}
modeldb.RemoveLinkSet(&tenant.LinkSets.NetProfiles, netProfile)
return nil
} | |
c8206 | links
modeldb.AddLink(&policy.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.Policies, policy)
// Save the tenant too since we added the links
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
return nil
} | |
c8207 | ":")
if sList == nil {
log.Errorf("EPG key %+v is not in valid format", epg.ObjKey)
return err
}
epgID := sList[1] + ":" + sList[0]
log.Infof("EPG ID : %s", epgID)
if err := epgCfg.Read(epgID); err != nil {
log.Errorf("Error fetching endpointGroup from mastercfg: %s", epgID)
return err
}
p... | |
c8208 | PolicyUpdate: %+v, params: %+v", policy, params)
return nil
} | |
c8209 | contivModel.DeleteRule(key)
if err != nil {
log.Errorf("Error deleting the rule: %s. Err: %v", key, err)
}
}
//Remove Links
modeldb.RemoveLinkSet(&tenant.LinkSets.Policies, policy)
// Save the tenant too since we added the links
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant s... | |
c8210 | RuleUpdate: %+v, params: %+v", rule, params)
return errors.New("can not update a rule after its created")
} | |
c8211 | "" {
epg = contivModel.FindEndpointGroup(epgKey)
if epg != nil {
modeldb.RemoveLinkSet(&epg.LinkSets.MatchRules, rule)
}
}
// Trigger policyDB Update
err = master.PolicyDelRule(policy, rule)
if err != nil {
log.Errorf("Error deleting rule %s to policy %s. Err: %v", rule.Key, policy.Key, err)
return e... | |
c8212 |
DefaultNetwork: tenant.DefaultNetwork,
}
// Create the tenant
err = master.CreateTenant(stateDriver, &tenantCfg)
if err != nil {
log.Errorf("Error creating tenant {%+v}. Err: %v", tenant, err)
return err
}
return nil
} | |
c8213 | if ep.NetID == networkID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []st... | |
c8214 | epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Addres... | |
c8215 |
tenant.Oper.TotalServicelbs = len(tenant.Config.LinkSets.Servicelbs)
//Get all the networks config and oper parmeters under this tenant
getTenantNetworks(tenant)
//Get all the EPGs config and oper parmeters under this tenant
getTenantEPGs(tenant)
return nil
} | |
c8216 | TenantUpdate: %+v, params: %+v", tenant, params)
return core.Errorf("Cant change tenant parameters after its created")
} | |
c8217 | associated networks, fail the delete
nwCount := len(tenant.LinkSets.Networks)
if nwCount != 0 {
return core.Errorf("cannot delete %s has %d networks",
tenant.TenantName, nwCount)
}
// Build tenant config
tenantCfg := intent.ConfigTenant{
Name: tenant.TenantName,
DefaultNetwork: tenant.DefaultN... | |
c8218 | bgpCfg.As,
NeighborAs: bgpCfg.NeighborAs,
Neighbor: bgpCfg.Neighbor,
}
// Add the Bgp neighbor
err = master.AddBgp(stateDriver, &bgpIntentCfg)
if err != nil {
log.Errorf("Error creating Bgp neighbor {%+v}. Err: %v", bgpCfg.Neighbor, err)
return err
}
return nil
} | |
c8219 |
err = master.DeleteBgp(stateDriver, bgpCfg.Hostname)
if err != nil {
log.Errorf("Error Deleting Bgp neighbor. Err: %v", err)
return err
}
return nil
} | |
c8220 | Add the Bgp neighbor
err = master.AddBgp(stateDriver, &bgpIntentCfg)
if err != nil {
log.Errorf("Error creating Bgp neighbor {%+v}. Err: %v", NewbgpCfg.Neighbor, err)
return err
}
oldbgpCfg.Hostname = NewbgpCfg.Hostname
oldbgpCfg.Routerip = NewbgpCfg.Routerip
oldbgpCfg.As = NewbgpCfg.As
oldbgpCfg.NeighborA... | |
c8221 | return err
}
if err := json.Unmarshal(response, &obj); err != nil {
return err
}
//Assuming bgp peer state will be only for one neighbor
if obj.Peers != nil {
nConf := obj.Peers[0]
bgp.Oper.NeighborStatus = string(nConf.State.SessionState)
bgp.Oper.AdminStatus = nConf.State.AdminState
}
if obj.Dsts !=... | |
c8222 | range serviceCfg.Selectors {
if validateSelectors(selector) {
key := strings.Split(selector, "=")[0]
value := strings.Split(selector, "=")[1]
serviceIntentCfg.Selectors[key] = value
} else {
return core.Errorf("Invalid selector %s. selector format is key1=value1", selector)
}
}
// Add the service o... | |
c8223 | serviceCfg.ServiceName
oldServiceCfg.TenantName = serviceCfg.TenantName
oldServiceCfg.NetworkName = serviceCfg.NetworkName
oldServiceCfg.IpAddress = serviceCfg.IpAddress
oldServiceCfg.Selectors = nil
oldServiceCfg.Ports = nil
oldServiceCfg.Selectors = append(oldServiceCfg.Selectors, serviceCfg.Selectors...)
old... | |
c8224 |
return core.Errorf("Tenant %s not found", serviceCfg.TenantName)
}
modeldb.RemoveLinkSet(&tenant.LinkSets.Servicelbs, serviceCfg)
tenant.Write()
nwKey := serviceCfg.TenantName + ":" + serviceCfg.NetworkName
network := contivModel.FindNetwork(nwKey)
if network == nil {
return core.Errorf("Network %s not fou... | |
c8225 | stateDriver
err := epCfg.Read(provider.EpIDKey)
if err != nil {
continue
}
epOper := contivModel.EndpointOper{}
epOper.Network = epCfg.NetID
epOper.EndpointID = epCfg.EndpointID
epOper.ServiceName = service.ServiceName //FIXME:fill in service name in endpoint
epOper.EndpointGroupID = epCfg.EndpointG... | |
c8226 | pluginConfig.Instance.StateDriver = p.StateDriver
err = InitGlobalSettings(p.StateDriver, &pluginConfig.Instance)
if err != nil {
return err
}
// initialize network driver
p.NetworkDriver, err = utils.NewNetworkDriver(pluginConfig.Drivers.Network, &pluginConfig.Instance)
if err != nil {
return err
}
p.Plu... | |
c8227 | if p.StateDriver != nil {
utils.ReleaseStateDriver()
p.StateDriver = nil
}
} | |
c8228 |
return p.NetworkDriver.DeleteNetwork(id, subnet, nwType, encap, pktTag, extPktTag, Gw, tenant)
} | |
c8229 | nil, core.Errorf("Not implemented")
} | |
c8230 |
return p.NetworkDriver.CreateHostAccPort(portName, globalIP, p.PluginConfig.Instance.HostPvtNW)
} | |
c8231 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteHostAccPort(portName)
} | |
c8232 | error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeletePeerHost(node)
} | |
c8233 | error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddSvcSpec(servicename, spec)
} | |
c8234 | error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DelSvcSpec(servicename, spec)
} | |
c8235 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GetEndpointStats()
} | |
c8236 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectState()
} | |
c8237 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectBgp()
} | |
c8238 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectNameserver()
} | |
c8239 |
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GlobalConfigUpdate(cfg.Instance)
} | |
c8240 | nil
}
cfg.Instance.StateDriver, _ = utils.GetStateDriver()
p.NetworkDriver, err = utils.NewNetworkDriver(cfg.Drivers.Network, &cfg.Instance)
logrus.Infof("Reinit Initializing NetworkDriver")
if err != nil {
logrus.Errorf("Reinit De-initializing due to error: %v", err)
p.NetworkDriver.Deinit()
}
} | |
c8241 | {
p.Lock()
defer p.Unlock()
p.NetworkDriver.DelSvcSpec(svcName, spec)
} | |
c8242 | {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddPolicyRule(id)
} | |
c8243 | init K8S client, %v", err)
return err
}
kubeNet := k8sContext{contivClient: contivClient, k8sClientSet: k8sClientSet, isLeader: isLeader}
go kubeNet.handleK8sEvents()
return nil
} | |
c8244 | to encode lat %v: %v", p.lat, err)
}
err = binary.Write(&buf, binary.LittleEndian, p.lng)
if err != nil {
return nil, fmt.Errorf("unable to encode lng %v: %v", p.lng, err)
}
return buf.Bytes(), nil
} | |
c8245 | := fmt.Sprintf(`{"lat":%v, "lng":%v}`, p.lat, p.lng)
return []byte(res), nil
} | |
c8246 |
if err != nil {
log.Print(err)
return err
}
*p = *NewPoint(values["lat"], values["lng"])
return nil
} | |
c8247 |
if err != nil {
panic(err)
}
s.sqlConn = db
return s, err
}
return nil, sqlConfErr
} | |
c8248 |
if len(res.Results) == 0 {
return nil, opencageZeroResultsError
}
lat := res.Results[0].Geometry.Lat
lng := res.Results[0].Geometry.Lng
point := &Point{
lat: lat,
lng: lng,
}
return point, nil
} | |
c8249 |
lat, err := strconv.ParseFloat(res[0].Lat, 64)
if err != nil {
return nil, err
}
lng, err := strconv.ParseFloat(res[0].Lng, 64)
if err != nil {
return nil, err
}
p := &Point{
lat: lat,
lng: lng,
}
return p, nil
} | |
c8250 | // Get latCol
latCol, latColError := config.Get(fmt.Sprintf("%s.latCol", goEnv))
if latColError != nil {
return nil, latColError
}
// Get lngCol
lngCol, lngColError := config.Get(fmt.Sprintf("%s.lngCol", goEnv))
if lngColError != nil {
return nil, lngColError
}
sqlConf := &SQLConf{driver: driver, openStr... | |
c8251 | p.points[end])
for i := 1; i < len(p.points); i++ {
if p.intersectsWithRaycast(point, p.points[i-1], p.points[i]) {
contains = !contains
}
}
return contains
} | |
c8252 | size = limit
}
return SizedWaitGroup{
Size: size,
current: make(chan struct{}, size),
wg: sync.WaitGroup{},
}
} | |
c8253 | case s.current <- struct{}{}:
break
}
s.wg.Add(1)
return nil
} | |
c8254 | json, 0, true,
opts.Width, opts.Prefix, opts.Indent, opts.SortKeys,
0, 0, -1)
if len(buf) > 0 {
buf = append(buf, '\n')
}
return buf
} | |
c8255 | := make([]byte, 0, len(json))
return ugly(buf, json)
} | |
c8256 | d.w.writeBlockDynamic(tok.tokens[:tok.n], eof, window)
}
} else {
d.w.writeBlock(tok.tokens[:tok.n], eof, nil)
}
d.blockStart = index
return d.w.err
}
return nil
} | |
c8257 | length = n
offset = pos - i
ok = true
if n >= nice {
// The match is good enough that we don't try to find a better one.
break
}
wEnd = win[pos+n]
}
}
if i == minIndex {
// hashPrev[i & windowMask] has already been overwritten, so stop now.
break
}
i = int(d.hashPrev[i... | |
c8258 | 1
for i := 1; i < end; i++ {
hb = (hb << 8) | uint32(b[i+3])
dst[i] = (hb * hashmul) >> (32 - hashBits)
}
} | |
c8259 |
if b[i] != av {
return i
}
}
return max
} | |
c8260 |
n := copy(d.window[d.windowEnd:], b)
d.windowEnd += n
return n
} | |
c8261 | = b[d.fill(d, b):]
if d.err != nil {
return 0, d.err
}
}
return n, d.err
} | |
c8262 | i := range d.hashPrev {
d.hashPrev[i] = 0
}
d.hashOffset = 1
d.index, d.windowEnd = 0, 0
d.blockStart, d.byteAvailable = 0, false
d.tokens.n = 0
d.length = minMatchLength - 1
d.offset = 0
d.hash = 0
d.ii = 0
d.maxInsertIndex = 0
}
} | |
c8263 | = append(zw.dict, dict...) // duplicate dictionary for Reset method.
return zw, err
} | |
c8264 | {
return w.d.write(data)
} | |
c8265 | w.d.reset(dw)
w.d.fillWindow(w.dict)
} else {
// w was created with NewWriter
w.d.reset(dst)
}
} | |
c8266 | []byte) {
w.dict = dict
w.d.reset(dst)
w.d.fillWindow(w.dict)
} | |
c8267 | return io.ErrUnexpectedEOF
}
return err
} | |
c8268 |
if err := z.Reset(r); err != nil {
return nil, err
}
return z, nil
} | |
c8269 | } else {
z.r = bufio.NewReader(r)
}
z.Header, z.err = z.readHeader()
return z.err
} | |
c8270 | z.digest = crc32.Update(z.digest, crc32.IEEETable, data)
hdr.Extra = data
}
var s string
if flg&flagName != 0 {
if s, err = z.readString(); err != nil {
return hdr, err
}
hdr.Name = s
}
if flg&flagComment != 0 {
if s, err = z.readString(); err != nil {
return hdr, err
}
hdr.Comment = s
}
... | |
c8271 | z.err = ErrChecksum
return n, z.err
}
z.digest, z.size = 0, 0
// File is ok; check if there is another.
if !z.multistream {
return n, io.EOF
}
z.err = nil // Remove io.EOF
if _, z.err = z.readHeader(); z.err != nil {
return n, z.err
}
// Read from next file, if necessary.
if n > 0 {
return n, nil... | |
c8272 |
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
b.nBits += bits
} | |
c8273 |
b.bitContainer |= uint64(value) << (b.nBits & 63)
b.nBits += bits
} | |
c8274 | byte(b.bitContainer>>16),
byte(b.bitContainer>>24))
b.nBits -= 32
b.bitContainer >>= 32
} | |
c8275 | append(b.out, byte(b.bitContainer>>(i*8)))
}
b.nBits = 0
b.bitContainer = 0
} | |
c8276 | 0
b.nBits = 0
b.out = out
} | |
c8277 | DefaultCompression)
return z
} | |
c8278 | level: %d", level)
}
z := new(Writer)
z.init(w, level)
return z, nil
} | |
c8279 | io.Writer) {
z.init(w, z.level)
} | |
c8280 | _, err := z.w.Write(z.buf[:2])
if err != nil {
return err
}
_, err = z.w.Write(b)
return err
} | |
c8281 |
if z.err != nil {
return n, z.err
}
}
if z.Name != "" {
z.err = z.writeString(z.Name)
if z.err != nil {
return n, z.err
}
}
if z.Comment != "" {
z.err = z.writeString(z.Comment)
if z.err != nil {
return n, z.err
}
}
if z.compressor == nil {
z.compressor, _ = flate.New... | |
c8282 | return z.err
}
}
z.err = z.compressor.Flush()
return z.err
} | |
c8283 |
default:
b.RLESize = 0
}
// Read block data.
if cap(b.data) < cSize {
if b.lowMem {
b.data = make([]byte, 0, cSize)
} else {
b.data = make([]byte, 0, maxBlockSize)
}
}
if cap(b.dst) <= maxBlockSize {
b.dst = make([]byte, 0, maxBlockSize+1)
}
var err error
b.data, err = br.readBig(cSize, b.dat... | |
c8284 | blockTypeReserved
b.err = err
b.input <- struct{}{}
} | |
c8285 |
close(b.history)
close(b.result)
} | |
c8286 | b.decodeCompressed(nil)
o := decodeOutput{
d: b,
b: b.dst,
err: err,
}
if debug {
println("Decompressed to", len(b.dst), "bytes, error:", err)
}
b.result <- o
case blockTypeReserved:
// Used for returning errors.
<-b.history
b.result <- decodeOutput{
d: b,
b: n... | |
c8287 | hist.b = nil
err := b.decodeCompressed(hist)
if debug {
println("Decompressed to total", len(b.dst), "bytes, error:", err)
}
hist.b = b.dst
b.dst = saved
return err
case blockTypeReserved:
// Used for returning errors.
return b.err
default:
panic("Invalid block type")
}
} | |
c8288 | return errors.New("corrupt stream, did not find end of stream")
}
b.bitsRead = 64
b.value = 0
b.fill()
b.fill()
b.bitsRead += 8 - uint8(highBits(uint32(v)))
return nil
} | |
c8289 | {
return io.ErrUnexpectedEOF
}
return nil
} | |
c8290 |
panic("decompressor already registered")
}
decompressors[method] = d
} | |
c8291 |
panic("compressor already registered")
}
compressors[method] = comp
} | |
c8292 | decoder not defined")
}
s.state.init(br, s.fse.actualTableLog, s.fse.dt[:1<<s.fse.actualTableLog])
return nil
} | |
c8293 |
return errors.New("matchLengths:" + err.Error())
}
s.literals = literals
s.hist = hist.b
s.prevOffset = hist.recentOffsets
s.maxBits = s.litLengths.fse.maxBits + s.offsets.fse.maxBits + s.matchLengths.fse.maxBits
s.out = out
return nil
} | |
c8294 | offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
mo++
}
if mo == 0 {
mo = s.prevOffset[0]
return
}
var temp int
if mo == 3 {
temp = s.prevOffset[0] - 1
} else {
temp = s.prevOffset[mo]
}
if temp == 0 {
// 0 is not valid; input is corrupted; force... | |
c8295 | return nil, fmt.Errorf("sequence stream %d, repeat requested, but no history", i)
}
continue
}
if sNew.fse == nil {
return nil, fmt.Errorf("sequence stream %d, no fse found", i)
}
if sHist.fse != nil && !sHist.fse.preDefined {
fseDecoderPool.Put(sHist.fse)
}
sHist.fse = sNew.fse
}
return hist... | |
c8296 |
s, err = s.prepare(in)
if err != nil {
return nil, false, err
}
return compress(in, s, s.compress1X)
} | |
c8297 | runtime.GOMAXPROCS(0) == 1 {
return compress(in, s, s.compress4X)
}
return compress(in, s, s.compress4Xp)
}
return compress(in, s, s.compress4X)
} | |
c8298 | src = src[len(toDo):]
// Separate goroutine for each block.
go func(i int) {
s.tmpOut[i], errs[i] = s.compress1xDo(s.tmpOut[i][:0], toDo)
wg.Done()
}(i)
}
wg.Wait()
for i := 0; i < 4; i++ {
if errs[i] != nil {
return nil, errs[i]
}
o := s.tmpOut[i]
// Write compressed length as little endia... | |
c8299 | := highBit32(uint32(s.symbolLen-1)) + 2
if minBitsSrc < minBitsSymbols {
return uint8(minBitsSrc)
}
return uint8(minBitsSymbols)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.