id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c162500 |
return nodeStore.NewNodeObserver(c.NodeManager)
} | |
c162501 | return nil, fmt.Errorf("unable to create config directory watcher: %s", err)
}
cm.configWatcher = w
if err := cm.configWatcher.watch(); err != nil {
return nil, err
}
return cm, nil
} | |
c162502 | range cm.clusters {
cluster.onRemove()
delete(cm.clusters, name)
}
cm.controllers.RemoveAllAndWait()
} | |
c162503 | := range cm.clusters {
if cm.isReady() {
nready++
}
}
return nready
} | |
c162504 | p.MemoryPercent()
cmdline, _ := p.Cmdline()
memExt := ""
if memInfo, err := p.MemoryInfo(); memInfo != nil && err == nil {
memExt = fmt.Sprintf("RSS: %d VMS: %d Data: %d Stack: %d Locked: %d Swap: %d",
toMB(memInfo.RSS), toMB(memInfo.VMS), toMB(memInfo.Data),
toMB(memInfo.Stack), toMB(mem... | |
c162505 | case <-closeChan:
return
default:
}
time.Sleep(interval)
}
}()
return closeChan
} | |
c162506 | return Client().ListAndWatch(name, prefix, chanSize)
} | |
c162507 | ruleReactionQueue.Run()
return &Repository{
revision: 1,
RepositoryChangeQueue: repoChangeQueue,
RuleReactionQueue: ruleReactionQueue,
}
} | |
c162508 |
if err != nil {
return nil, err
}
return &result.Egress, nil
} | |
c162509 | *CIDRPolicy {
return p.rules.resolveCIDRPolicy(ctx)
} | |
c162510 | != nil {
log.WithError(err).Warn("Evaluation error while resolving L4 ingress policy")
}
verdict := api.Denied
if err == nil && len(*ingressPolicy) > 0 {
verdict = ingressPolicy.IngressCoversContext(ctx)
}
ctx.PolicyTrace("Ingress verdict: %s", verdict.String())
return verdict
} | |
c162511 | err != nil {
log.WithError(err).Warn("Evaluation error while resolving L4 egress policy")
}
verdict := api.Denied
if err == nil && len(*egressPolicy) > 0 {
verdict = egressPolicy.EgressCoversContext(ctx)
}
ctx.PolicyTrace("Egress verdict: %s", verdict.String())
return verdict
} | |
c162512 |
if r.Labels.Contains(labels) {
result = append(result, &r.Rule)
}
}
return result
} | |
c162513 | newList[i] = newRule
}
p.rules = append(p.rules, newList...)
p.BumpRevision()
metrics.PolicyCount.Add(float64(len(newList)))
return newList, p.GetRevision()
} | |
c162514 | wg.Add(len(p.rules))
for _, r := range p.rules {
go func(rr *rule, wgg *sync.WaitGroup) {
rr.metadata.delete(identity)
wgg.Done()
}(r, &wg)
}
return &wg
} | |
c162515 | scopedLog.Debug("Removing identity references from policy cache")
p.Mutex.RLock()
wg := p.removeIdentityFromRuleCaches(identity)
wg.Wait()
p.Mutex.RUnlock()
scopedLog.Debug("Finished cleaning policy cache")
}()
} | |
c162516 |
defer p.Mutex.Unlock()
return p.AddListLocked(rules)
} | |
c162517 | If we could not evaluate the rules against the current endpoint, or
// the endpoint is not selected by the rules, remove it from the set
// of endpoints to bump the revision. If the error is non-nil, the
// endpoint is no longer in either set (endpointsToBumpRevision or
// endpointsToRegenerate, as we could no... | |
c162518 | deleted > 0 {
p.BumpRevision()
p.rules = new
metrics.PolicyCount.Sub(float64(deleted))
}
return deletedRules, p.GetRevision(), deleted
} | |
c162519 | p.Mutex.Lock()
defer p.Mutex.Unlock()
_, rev, numDeleted := p.DeleteByLabelsLocked(labels)
return rev, numDeleted
} | |
c162520 | "", " ")
if err != nil {
return err.Error()
}
return string(b)
} | |
c162521 | := api.Rules{}
for _, r := range p.rules {
result = append(result, &r.Rule)
}
return JSONMarshalRules(result)
} | |
c162522 | {
ingressMatch = true
}
if len(r.Egress) > 0 {
egressMatch = true
}
}
if ingressMatch && egressMatch {
return
}
}
return
} | |
c162523 | // lenth of slice.
if !ingressMatch && len(r.Ingress) > 0 {
ingressMatch = true
}
if !egressMatch && len(r.Egress) > 0 {
egressMatch = true
}
matchingRules = append(matchingRules, r)
}
}
return
} | |
c162524 | p.Mutex.Unlock()
return p.NumRules() == 0
} | |
c162525 | := &TranslationResult{}
for ruleIndex := range p.rules {
if err := translator.Translate(&p.rules[ruleIndex].Rule, result); err != nil {
return nil, err
}
}
return result, nil
} | |
c162526 |
atomic.AddUint64(&p.revision, 1)
} | |
c162527 |
ruleList := p.SearchRLocked(lbls)
return &models.Policy{
Revision: int64(p.GetRevision()),
Policy: JSONMarshalRules(ruleList),
}
} | |
c162528 | TRACE_ENABLED
}
if ingressEnabled {
newL4IngressPolicy, err := matchingRules.resolveL4IngressPolicy(&ingressCtx, p.GetRevision())
if err != nil {
return nil, err
}
newCIDRIngressPolicy := matchingRules.resolveCIDRPolicy(&ingressCtx)
if err := newCIDRIngressPolicy.Validate(); err != nil {
return nil... | |
c162529 | enforce policy (default deny).
if lbls.Has(labels.IDNameInit) {
return true, true, matchingRules
}
// Default mode means that if rules contain labels that match this
// endpoint, then enable policy enforcement for this endpoint.
return ingress, egress, matchingRules
default:
// If policy enforcement i... | |
c162530 | &GetIdentityID{Context: ctx, Handler: handler}
} | |
c162531 | labels.NewLabel(lbl, "", labels.LabelSourceReserved)})
// Pre-calculate the SHA256 hash.
identity.GetLabelsSHA256()
ReservedIdentityCache[ni] = identity
} | |
c162532 | &PutEndpointID{Context: ctx, Handler: handler}
} | |
c162533 | runtime.JSONConsumer(),
JSONProducer: runtime.JSONProducer(),
GetHealthzHandler: GetHealthzHandlerFunc(func(params GetHealthzParams) middleware.Responder {
return middleware.NotImplemented("operation GetHealthz has not yet been implemented")
}),
GetHelloHandler: GetHelloHandlerFunc(func(params Get... | |
c162534 |
if o.GetHelloHandler == nil {
unregistered = append(unregistered, "GetHelloHandler")
}
if o.ConnectivityGetStatusHandler == nil {
unregistered = append(unregistered, "connectivity.GetStatusHandler")
}
if o.ConnectivityPutStatusProbeHandler == nil {
unregistered = append(unregistered, "connectivity.PutSta... | |
c162535 | == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | |
c162536 |
n.DestPort = byteorder.HostToNetwork(n.DestPort).(uint16)
return &n
} | |
c162537 | if err != nil {
return nil, fmt.Errorf("Can not open CT map %s: %s", mapname, err)
}
}
v, err := m.Lookup(key)
if err != nil || v == nil {
return nil, err
}
return v.(*CtEntry), err
} | |
c162538 | IPv6 maps, if any
if m := getMapWithName(mapname, false, u8proto.TCP); m != nil {
m.Close()
}
if m := getMapWithName(mapname, false, u8proto.UDP); m != nil {
m.Close()
}
}
} | |
c162539 | Port: fmt.Sprintf("%d", dp.Port),
Protocol: api.L4Proto(dp.Protocol),
}
if p.Covers(tracePort) {
return true
}
}
}
return false
} | |
c162540 | the BPF maps
// for allowing traffic by CIDR!
for _, egressRule := range r.Egress {
var allCIDRs []api.CIDR
allCIDRs = append(allCIDRs, egressRule.ToCIDR...)
allCIDRs = append(allCIDRs, api.ComputeResultantCIDRSet(egressRule.ToCIDRSet)...)
// Unlike the Ingress policy which only counts L3 policy in
// thi... | |
c162541 | // If a requirement explicitly denies access, we can return.
if r.meetsRequirementsIngress(ctx, state) == api.Denied {
return api.Denied
}
return r.canReachFromEndpoints(ctx, state)
} | |
c162542 | Requires from labels %+v", sel)
if !sel.Matches(ctx.From) {
ctx.PolicyTrace("- Labels %v not found\n", ctx.From)
state.constrainedRules++
return api.Denied
}
ctx.PolicyTrace("+ Found all required labels\n")
}
}
return api.Undecided
} | |
c162543 | Requires from labels %+v", sel)
if !sel.Matches(ctx.To) {
ctx.PolicyTrace("- Labels %v not found\n", ctx.To)
state.constrainedRules++
return api.Denied
}
ctx.PolicyTrace("+ Found all required labels\n")
}
}
return api.Undecided
} | |
c162544 | exists {
return v
}
return ""
} | |
c162545 | := stringToDecision[string(b[1:len(b)-1])]; exists {
*d = v
return nil
}
return fmt.Errorf("unknown '%s' decision", string(b))
} | |
c162546 | []byte(fmt.Sprintf(`"%s"`, d)), nil
} | |
c162547 | when sending
// - Must use separate sockets for IPv4/IPv6, as sending to a v6-mapped
// v4 address from a socket bound to "::1" does not work due to kernel
// checking that a route exists from the source address before
// the source address is replaced with the (transparently) changed one
udpOnce.Do(func() ... | |
c162548 | make([]byte, msgSize),
oob: make([]byte, udpOOBSize),
}
}
} | |
c162549 | size
s.oob = s.oob[:oobn] // Re-slice to the actual size
s.laddr, err = parseDstFromOOB(s.oob)
if err != nil {
s.Discard()
return nil, nil, err
}
return s.m, s, err
} | |
c162550 | s.oob = s.oob[:cap(s.oob)]
s.f.udpPool.Put(s)
} | |
c162551 | if s.raddr.IP.To4() == nil {
n, _, err = rawconn6.WriteMsgIP(buf, s.controlMessage(s.laddr), &dst)
} else {
n, _, err = rawconn4.WriteMsgIP(buf, s.controlMessage(s.laddr), &dst)
}
if err != nil {
log.Warningf("WriteMsgIP: %s", err)
} else {
log.Debugf("WriteMsgIP: wrote %d bytes", n)
}
return n, err
} | |
c162552 |
family := *(*uint16)(unsafe.Pointer(&msg.Data[unsafe.Offsetof(pp.Family)]))
if family != unix.AF_INET6 {
return nil, fmt.Errorf("original destination is not IPv6.")
}
// Scope ID is in native byte order
scopeId := *(*uint32)(unsafe.Pointer(&msg.Data[unsafe.Offsetof(pp.Scope_id)]))
// Rest of the ... | |
c162553 | cm := new(ipv6.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
}
cm := new(ipv4.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
} | |
c162554 | proxyID)
return
}
epID, err := strconv.ParseUint(comps[0], 10, 16)
if err != nil {
return
}
endpointID = uint16(epID)
ingress = comps[1] == "ingress"
protocol = comps[2]
l4port, err := strconv.ParseUint(comps[3], 10, 16)
if err != nil {
return
}
port = uint16(l4port)
return
} | |
c162555 | return ps[s.Status.Type] == s
} | |
c162556 | append(prs, k)
}
sort.Sort(prs)
slogSorted := statusLog{}
for _, pr := range prs {
slogSorted = append(slogSorted, ps[pr])
}
return slogSorted
} | |
c162557 | log to prevent removing
// non-OK status!
if e.Index < len(e.Log) &&
e.CurrentStatuses.contains(e.Log[e.Index]) &&
e.Log[e.Index].Status.Code != OK {
e.Index++
if e.Index >= maxLogs {
e.Index = 0
}
}
return idx
} | |
c162558 | == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | |
c162559 | meta.ReadBinary(bytes.NewReader(data))
} | |
c162560 |
if err := meta.WriteBinary(&buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c162561 | binary.Read(r, byteorder.Native, meta)
} | |
c162562 | binary.Write(w, byteorder.Native, meta)
} | |
c162563 | method, resulting in infinite recursion.
return pl.ReadBinary(bytes.NewBuffer(data))
} | |
c162564 | call
// this method, resulting in infinite recursion.
var buf bytes.Buffer
if err := pl.WriteBinary(&buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c162565 | := gob.NewDecoder(r)
return pl.DecodeBinary(dec)
} | |
c162566 | := gob.NewEncoder(w)
return pl.EncodeBinary(enc)
} | |
c162567 | *gob.Encoder) error {
return enc.Encode(pl)
} | |
c162568 | *gob.Decoder) error {
return dec.Decode(pl)
} | |
c162569 |
}
// Meta.Size is not necessary for framing/decoding, but is useful to validate the payload size.
return pl.ReadBinary(io.LimitReader(r, int64(meta.Size)))
} | |
c162570 | if err != nil {
return err
}
meta.Size = uint32(len(payloadBuf))
meta.WriteBinary(w)
_, err = w.Write(payloadBuf)
return err
} | |
c162571 | != nil {
return nil, fmt.Errorf("unable to encode metadata: %s", err)
}
return append(metaBuf, plBuf...), nil
} | |
c162572 | uint(unix.IFNAMSIZ - len(temporaryInterfacePrefix) - 1)
return hostInterfacePrefix + truncateString(sum, truncateLength)
} | |
c162573 | f.Close()
return fmt.Errorf("unable to write value: %s", err)
}
err = f.Close()
if err != nil {
return fmt.Errorf("unable to close configuration file: %s", err)
}
return nil
} | |
c162574 | != nil {
return err
}
for _, l := range links {
addrs, err := netlink.AddrList(l, netlink.FAMILY_V4)
if err != nil {
return err
}
for _, addr := range addrs {
if addr.IP.IsGlobalUnicast() {
ip = addr.IP
lxcMAC = l.Attrs().HardwareAddr.String()
parentIndex = l.Attrs().ParentInd... | |
c162575 | nil {
res = append(res, err)
}
if err := m.validatePolicy(formats); err != nil {
res = append(res, err)
}
if err := m.validateServiceList(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | |
c162576 | k.val)
}
k.refcnt++
kvstore.Trace("Incremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: val, fieldRefCnt: k.refcnt})
return k.val, nil
}
k := &localKey{key: key, val: val, refcnt: 1}
lk.keys[key] = k
lk.ids[val] = k
kvstore.Trace("New local key", nil, logrus.Fields{fieldKey: key, fi... | |
c162577 | lk.ids[id]; ok {
return k.key
}
return ""
} | |
c162578 |
kvstore.Trace("Incremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: k.val, fieldRefCnt: k.refcnt})
return k.val
}
return idpool.NoID
} | |
c162579 | delete(lk.keys, key)
delete(lk.ids, k.val)
return true, nil
}
return false, nil
}
return false, fmt.Errorf("unable to find key in local cache")
} | |
c162580 | if err != nil {
return nil, err
}
if err := newHash.(encoding.BinaryUnmarshaler).UnmarshalBinary(state); err != nil {
return nil, err
}
return &digest{
newHash,
}, nil
} | |
c162581 | *PostIPAMCreated {
o.Payload = payload
return o
} | |
c162582 | {
o.Payload = payload
return o
} | |
c162583 | return nil, Hint(err)
}
return resp.Payload, nil
} | |
c162584 | c.Prefilter.PatchPrefilter(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | |
c162585 | deleteSet[delCIDR] = true
}
if current.Status != nil && current.Status.Realized != nil {
for _, keepCIDR := range current.Status.Realized.Deny {
if !deleteSet[keepCIDR] {
keepList = append(keepList, keepCIDR)
}
}
}
update := current.Status.Realized
update.Deny = keepList
_, err = c.PatchPrefilter... | |
c162586 | time.Duration) *GetConfigParams {
o.SetTimeout(timeout)
return o
} | |
c162587 | *GetConfigParams {
o.SetContext(ctx)
return o
} | |
c162588 | o.SetHTTPClient(client)
return o
} | |
c162589 | *GetFqdnCacheIDOK {
o.Payload = payload
return o
} | |
c162590 | models.Error) *GetFqdnCacheIDBadRequest {
o.Payload = payload
return o
} | |
c162591 | nil, errors.New(`Only alphanumeric ASCII characters, the hyphen "-", "." and "*" are allowed in a matchPattern`)
}
return regexp.Compile(ToRegexp(pattern))
} | |
c162592 |
return strings.ToLower(dns.Fqdn(pattern))
} | |
c162593 | nil
}
return &CIDR{ipnet}
} | |
c162594 | Mask: make([]byte, len(n.Mask)),
},
}
copy(out.IP, n.IP)
copy(out.Mask, n.Mask)
return out
} | |
c162595 | return nil, err
}
return NewCIDR(ipnet), nil
} | |
c162596 | to parse CIDR '%s': %s", str, err))
}
return c
} | |
c162597 | {
o.SetTimeout(timeout)
return o
} | |
c162598 | *GetPrefilterParams {
o.SetContext(ctx)
return o
} | |
c162599 | *http.Client) *GetPrefilterParams {
o.SetHTTPClient(client)
return o
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.