id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
162,500 | cilium/cilium | pkg/clustermesh/clustermesh.go | NodeObserver | func (c *Configuration) NodeObserver() store.Observer {
if c.nodeObserver != nil {
return c.nodeObserver
}
return nodeStore.NewNodeObserver(c.NodeManager)
} | go | func (c *Configuration) NodeObserver() store.Observer {
if c.nodeObserver != nil {
return c.nodeObserver
}
return nodeStore.NewNodeObserver(c.NodeManager)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"NodeObserver",
"(",
")",
"store",
".",
"Observer",
"{",
"if",
"c",
".",
"nodeObserver",
"!=",
"nil",
"{",
"return",
"c",
".",
"nodeObserver",
"\n",
"}",
"\n\n",
"return",
"nodeStore",
".",
"NewNodeObserver",
... | // NodeObserver returns the node store observer of the configuration | [
"NodeObserver",
"returns",
"the",
"node",
"store",
"observer",
"of",
"the",
"configuration"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/clustermesh.go#L61-L67 |
162,501 | cilium/cilium | pkg/clustermesh/clustermesh.go | NewClusterMesh | func NewClusterMesh(c Configuration) (*ClusterMesh, error) {
cm := &ClusterMesh{
conf: c,
clusters: map[string]*remoteCluster{},
controllers: controller.NewManager(),
globalServices: newGlobalServiceCache(),
}
w, err := createConfigDirectoryWatcher(c.ConfigDirectory, cm)
if err != nil {
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
} | go | func NewClusterMesh(c Configuration) (*ClusterMesh, error) {
cm := &ClusterMesh{
conf: c,
clusters: map[string]*remoteCluster{},
controllers: controller.NewManager(),
globalServices: newGlobalServiceCache(),
}
w, err := createConfigDirectoryWatcher(c.ConfigDirectory, cm)
if err != nil {
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
} | [
"func",
"NewClusterMesh",
"(",
"c",
"Configuration",
")",
"(",
"*",
"ClusterMesh",
",",
"error",
")",
"{",
"cm",
":=",
"&",
"ClusterMesh",
"{",
"conf",
":",
"c",
",",
"clusters",
":",
"map",
"[",
"string",
"]",
"*",
"remoteCluster",
"{",
"}",
",",
"c... | // NewClusterMesh creates a new remote cluster cache based on the
// provided configuration | [
"NewClusterMesh",
"creates",
"a",
"new",
"remote",
"cluster",
"cache",
"based",
"on",
"the",
"provided",
"configuration"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/clustermesh.go#L86-L106 |
162,502 | cilium/cilium | pkg/clustermesh/clustermesh.go | Close | func (cm *ClusterMesh) Close() {
cm.mutex.Lock()
defer cm.mutex.Unlock()
if cm.configWatcher != nil {
cm.configWatcher.close()
}
for name, cluster := range cm.clusters {
cluster.onRemove()
delete(cm.clusters, name)
}
cm.controllers.RemoveAllAndWait()
} | go | func (cm *ClusterMesh) Close() {
cm.mutex.Lock()
defer cm.mutex.Unlock()
if cm.configWatcher != nil {
cm.configWatcher.close()
}
for name, cluster := range cm.clusters {
cluster.onRemove()
delete(cm.clusters, name)
}
cm.controllers.RemoveAllAndWait()
} | [
"func",
"(",
"cm",
"*",
"ClusterMesh",
")",
"Close",
"(",
")",
"{",
"cm",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cm",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"cm",
".",
"configWatcher",
"!=",
"nil",
"{",
"cm",
".",
"c... | // Close stops watching for remote cluster configuration files to appear and
// will close all connections to remote clusters | [
"Close",
"stops",
"watching",
"for",
"remote",
"cluster",
"configuration",
"files",
"to",
"appear",
"and",
"will",
"close",
"all",
"connections",
"to",
"remote",
"clusters"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/clustermesh.go#L110-L124 |
162,503 | cilium/cilium | pkg/clustermesh/clustermesh.go | NumReadyClusters | func (cm *ClusterMesh) NumReadyClusters() int {
cm.mutex.RLock()
defer cm.mutex.RUnlock()
nready := 0
for _, cm := range cm.clusters {
if cm.isReady() {
nready++
}
}
return nready
} | go | func (cm *ClusterMesh) NumReadyClusters() int {
cm.mutex.RLock()
defer cm.mutex.RUnlock()
nready := 0
for _, cm := range cm.clusters {
if cm.isReady() {
nready++
}
}
return nready
} | [
"func",
"(",
"cm",
"*",
"ClusterMesh",
")",
"NumReadyClusters",
"(",
")",
"int",
"{",
"cm",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"cm",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"nready",
":=",
"0",
"\n",
"for",
"_",
",",
"cm... | // NumReadyClusters returns the number of remote clusters to which a connection
// has been established | [
"NumReadyClusters",
"returns",
"the",
"number",
"of",
"remote",
"clusters",
"to",
"which",
"a",
"connection",
"has",
"been",
"established"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/clustermesh.go#L177-L189 |
162,504 | cilium/cilium | pkg/loadinfo/loadinfo.go | LogCurrentSystemLoad | func LogCurrentSystemLoad(logFunc LogFunc) {
loadInfo, err := load.Avg()
if err == nil {
logFunc("Load 1-min: %.2f 5-min: %.2f 15min: %.2f",
loadInfo.Load1, loadInfo.Load5, loadInfo.Load15)
}
memInfo, err := mem.VirtualMemory()
if err == nil && memInfo != nil {
logFunc("Memory: Total: %d Used: %d (%.2f%%) Free: %d Buffers: %d Cached: %d",
toMB(memInfo.Total), toMB(memInfo.Used), memInfo.UsedPercent, toMB(memInfo.Free), toMB(memInfo.Buffers), toMB(memInfo.Cached))
}
swapInfo, err := mem.SwapMemory()
if err == nil && swapInfo != nil {
logFunc("Swap: Total: %d Used: %d (%.2f%%) Free: %d",
toMB(swapInfo.Total), toMB(swapInfo.Used), swapInfo.UsedPercent, toMB(swapInfo.Free))
}
procs, err := process.Processes()
if err == nil {
for _, p := range procs {
cpuPercent, _ := p.CPUPercent()
if cpuPercent > cpuWatermark {
name, _ := p.Name()
status, _ := p.Status()
memPercent, _ := 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(memInfo.Locked), toMB(memInfo.Swap))
}
logFunc("NAME %s STATUS %s PID %d CPU: %.2f%% MEM: %.2f%% CMDLINE: %s MEM-EXT: %s",
name, status, p.Pid, cpuPercent, memPercent, cmdline, memExt)
}
}
}
} | go | func LogCurrentSystemLoad(logFunc LogFunc) {
loadInfo, err := load.Avg()
if err == nil {
logFunc("Load 1-min: %.2f 5-min: %.2f 15min: %.2f",
loadInfo.Load1, loadInfo.Load5, loadInfo.Load15)
}
memInfo, err := mem.VirtualMemory()
if err == nil && memInfo != nil {
logFunc("Memory: Total: %d Used: %d (%.2f%%) Free: %d Buffers: %d Cached: %d",
toMB(memInfo.Total), toMB(memInfo.Used), memInfo.UsedPercent, toMB(memInfo.Free), toMB(memInfo.Buffers), toMB(memInfo.Cached))
}
swapInfo, err := mem.SwapMemory()
if err == nil && swapInfo != nil {
logFunc("Swap: Total: %d Used: %d (%.2f%%) Free: %d",
toMB(swapInfo.Total), toMB(swapInfo.Used), swapInfo.UsedPercent, toMB(swapInfo.Free))
}
procs, err := process.Processes()
if err == nil {
for _, p := range procs {
cpuPercent, _ := p.CPUPercent()
if cpuPercent > cpuWatermark {
name, _ := p.Name()
status, _ := p.Status()
memPercent, _ := 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(memInfo.Locked), toMB(memInfo.Swap))
}
logFunc("NAME %s STATUS %s PID %d CPU: %.2f%% MEM: %.2f%% CMDLINE: %s MEM-EXT: %s",
name, status, p.Pid, cpuPercent, memPercent, cmdline, memExt)
}
}
}
} | [
"func",
"LogCurrentSystemLoad",
"(",
"logFunc",
"LogFunc",
")",
"{",
"loadInfo",
",",
"err",
":=",
"load",
".",
"Avg",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"logFunc",
"(",
"\"",
"\"",
",",
"loadInfo",
".",
"Load1",
",",
"loadInfo",
".",
"Lo... | // LogCurrentSystemLoad logs the current system load and lists all processes
// consuming more than cpuWatermark of the CPU | [
"LogCurrentSystemLoad",
"logs",
"the",
"current",
"system",
"load",
"and",
"lists",
"all",
"processes",
"consuming",
"more",
"than",
"cpuWatermark",
"of",
"the",
"CPU"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/loadinfo/loadinfo.go#L53-L94 |
162,505 | cilium/cilium | pkg/loadinfo/loadinfo.go | LogPeriodicSystemLoad | func LogPeriodicSystemLoad(logFunc LogFunc, interval time.Duration) CloseChan {
closeChan := make(CloseChan)
go func() {
for {
LogCurrentSystemLoad(logFunc)
select {
case <-closeChan:
return
default:
}
time.Sleep(interval)
}
}()
return closeChan
} | go | func LogPeriodicSystemLoad(logFunc LogFunc, interval time.Duration) CloseChan {
closeChan := make(CloseChan)
go func() {
for {
LogCurrentSystemLoad(logFunc)
select {
case <-closeChan:
return
default:
}
time.Sleep(interval)
}
}()
return closeChan
} | [
"func",
"LogPeriodicSystemLoad",
"(",
"logFunc",
"LogFunc",
",",
"interval",
"time",
".",
"Duration",
")",
"CloseChan",
"{",
"closeChan",
":=",
"make",
"(",
"CloseChan",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"LogCurrentSystemLoad",
"(",
"logFun... | // LogPeriodicSystemLoad logs the system load in the interval specified until
// the channel is closed | [
"LogPeriodicSystemLoad",
"logs",
"the",
"system",
"load",
"in",
"the",
"interval",
"specified",
"until",
"the",
"channel",
"is",
"closed"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/loadinfo/loadinfo.go#L98-L115 |
162,506 | cilium/cilium | pkg/kvstore/events.go | ListAndWatch | func ListAndWatch(name, prefix string, chanSize int) *Watcher {
return Client().ListAndWatch(name, prefix, chanSize)
} | go | func ListAndWatch(name, prefix string, chanSize int) *Watcher {
return Client().ListAndWatch(name, prefix, chanSize)
} | [
"func",
"ListAndWatch",
"(",
"name",
",",
"prefix",
"string",
",",
"chanSize",
"int",
")",
"*",
"Watcher",
"{",
"return",
"Client",
"(",
")",
".",
"ListAndWatch",
"(",
"name",
",",
"prefix",
",",
"chanSize",
")",
"\n",
"}"
] | // ListAndWatch creates a new watcher which will watch the specified prefix for
// changes. Before doing this, it will list the current keys matching the
// prefix and report them as new keys. Name can be set to anything and is used
// for logging messages. The Events channel is created with the specified
// sizes. Upon every change observed, a KeyValueEvent will be sent to the
// Events channel
//
// Returns a watcher structure plus a channel that is closed when the initial
// list operation has been completed | [
"ListAndWatch",
"creates",
"a",
"new",
"watcher",
"which",
"will",
"watch",
"the",
"specified",
"prefix",
"for",
"changes",
".",
"Before",
"doing",
"this",
"it",
"will",
"list",
"the",
"current",
"keys",
"matching",
"the",
"prefix",
"and",
"report",
"them",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/kvstore/events.go#L112-L114 |
162,507 | cilium/cilium | pkg/policy/repository.go | NewPolicyRepository | func NewPolicyRepository() *Repository {
repoChangeQueue := eventqueue.NewEventQueueBuffered("repository-change-queue", option.Config.PolicyQueueSize)
ruleReactionQueue := eventqueue.NewEventQueueBuffered("repository-reaction-queue", option.Config.PolicyQueueSize)
repoChangeQueue.Run()
ruleReactionQueue.Run()
return &Repository{
revision: 1,
RepositoryChangeQueue: repoChangeQueue,
RuleReactionQueue: ruleReactionQueue,
}
} | go | func NewPolicyRepository() *Repository {
repoChangeQueue := eventqueue.NewEventQueueBuffered("repository-change-queue", option.Config.PolicyQueueSize)
ruleReactionQueue := eventqueue.NewEventQueueBuffered("repository-reaction-queue", option.Config.PolicyQueueSize)
repoChangeQueue.Run()
ruleReactionQueue.Run()
return &Repository{
revision: 1,
RepositoryChangeQueue: repoChangeQueue,
RuleReactionQueue: ruleReactionQueue,
}
} | [
"func",
"NewPolicyRepository",
"(",
")",
"*",
"Repository",
"{",
"repoChangeQueue",
":=",
"eventqueue",
".",
"NewEventQueueBuffered",
"(",
"\"",
"\"",
",",
"option",
".",
"Config",
".",
"PolicyQueueSize",
")",
"\n",
"ruleReactionQueue",
":=",
"eventqueue",
".",
... | // NewPolicyRepository allocates a new policy repository | [
"NewPolicyRepository",
"allocates",
"a",
"new",
"policy",
"repository"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L57-L67 |
162,508 | cilium/cilium | pkg/policy/repository.go | ResolveL4EgressPolicy | func (p *Repository) ResolveL4EgressPolicy(ctx *SearchContext) (*L4PolicyMap, error) {
result, err := p.rules.resolveL4EgressPolicy(ctx, p.GetRevision())
if err != nil {
return nil, err
}
return &result.Egress, nil
} | go | func (p *Repository) ResolveL4EgressPolicy(ctx *SearchContext) (*L4PolicyMap, error) {
result, err := p.rules.resolveL4EgressPolicy(ctx, p.GetRevision())
if err != nil {
return nil, err
}
return &result.Egress, nil
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"ResolveL4EgressPolicy",
"(",
"ctx",
"*",
"SearchContext",
")",
"(",
"*",
"L4PolicyMap",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"p",
".",
"rules",
".",
"resolveL4EgressPolicy",
"(",
"ctx",
",",
"p",
... | // ResolveL4EgressPolicy resolves the L4 egress policy for a set of endpoints
// by searching the policy repository for `PortRule` rules that are attached to
// a `Rule` where the EndpointSelector matches `ctx.From`. `ctx.To` takes no effect and
// is ignored in the search. If multiple `PortRule` rules are found, all rules
// are merged together. If rules contains overlapping port definitions, the first
// rule found in the repository takes precedence. | [
"ResolveL4EgressPolicy",
"resolves",
"the",
"L4",
"egress",
"policy",
"for",
"a",
"set",
"of",
"endpoints",
"by",
"searching",
"the",
"policy",
"repository",
"for",
"PortRule",
"rules",
"that",
"are",
"attached",
"to",
"a",
"Rule",
"where",
"the",
"EndpointSelec... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L176-L184 |
162,509 | cilium/cilium | pkg/policy/repository.go | ResolveCIDRPolicy | func (p *Repository) ResolveCIDRPolicy(ctx *SearchContext) *CIDRPolicy {
return p.rules.resolveCIDRPolicy(ctx)
} | go | func (p *Repository) ResolveCIDRPolicy(ctx *SearchContext) *CIDRPolicy {
return p.rules.resolveCIDRPolicy(ctx)
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"ResolveCIDRPolicy",
"(",
"ctx",
"*",
"SearchContext",
")",
"*",
"CIDRPolicy",
"{",
"return",
"p",
".",
"rules",
".",
"resolveCIDRPolicy",
"(",
"ctx",
")",
"\n",
"}"
] | // ResolveCIDRPolicy resolves the L3 policy for a set of endpoints by searching
// the policy repository for `CIDR` rules that are attached to a `Rule`
// where the EndpointSelector matches `ctx.To`. `ctx.From` takes no effect and
// is ignored in the search. | [
"ResolveCIDRPolicy",
"resolves",
"the",
"L3",
"policy",
"for",
"a",
"set",
"of",
"endpoints",
"by",
"searching",
"the",
"policy",
"repository",
"for",
"CIDR",
"rules",
"that",
"are",
"attached",
"to",
"a",
"Rule",
"where",
"the",
"EndpointSelector",
"matches",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L190-L192 |
162,510 | cilium/cilium | pkg/policy/repository.go | AllowsIngressRLocked | func (p *Repository) AllowsIngressRLocked(ctx *SearchContext) api.Decision {
// Lack of DPorts in the SearchContext means L3-only search
if len(ctx.DPorts) == 0 {
newCtx := *ctx
newCtx.DPorts = []*models.Port{{
Port: 0,
Protocol: models.PortProtocolANY,
}}
ctx = &newCtx
}
ctx.PolicyTrace("Tracing %s", ctx.String())
ingressPolicy, err := p.ResolveL4IngressPolicy(ctx)
if err != 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
} | go | func (p *Repository) AllowsIngressRLocked(ctx *SearchContext) api.Decision {
// Lack of DPorts in the SearchContext means L3-only search
if len(ctx.DPorts) == 0 {
newCtx := *ctx
newCtx.DPorts = []*models.Port{{
Port: 0,
Protocol: models.PortProtocolANY,
}}
ctx = &newCtx
}
ctx.PolicyTrace("Tracing %s", ctx.String())
ingressPolicy, err := p.ResolveL4IngressPolicy(ctx)
if err != 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
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"AllowsIngressRLocked",
"(",
"ctx",
"*",
"SearchContext",
")",
"api",
".",
"Decision",
"{",
"// Lack of DPorts in the SearchContext means L3-only search",
"if",
"len",
"(",
"ctx",
".",
"DPorts",
")",
"==",
"0",
"{",
"new... | // AllowsIngressRLocked evaluates the policy repository for the provided search
// context and returns the verdict for ingress. If no matching policy allows for
// the connection, the request will be denied. The policy repository mutex must
// be held. | [
"AllowsIngressRLocked",
"evaluates",
"the",
"policy",
"repository",
"for",
"the",
"provided",
"search",
"context",
"and",
"returns",
"the",
"verdict",
"for",
"ingress",
".",
"If",
"no",
"matching",
"policy",
"allows",
"for",
"the",
"connection",
"the",
"request",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L198-L222 |
162,511 | cilium/cilium | pkg/policy/repository.go | AllowsEgressRLocked | func (p *Repository) AllowsEgressRLocked(ctx *SearchContext) api.Decision {
// Lack of DPorts in the SearchContext means L3-only search
if len(ctx.DPorts) == 0 {
newCtx := *ctx
newCtx.DPorts = []*models.Port{{
Port: 0,
Protocol: models.PortProtocolANY,
}}
ctx = &newCtx
}
ctx.PolicyTrace("Tracing %s\n", ctx.String())
egressPolicy, err := p.ResolveL4EgressPolicy(ctx)
if 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
} | go | func (p *Repository) AllowsEgressRLocked(ctx *SearchContext) api.Decision {
// Lack of DPorts in the SearchContext means L3-only search
if len(ctx.DPorts) == 0 {
newCtx := *ctx
newCtx.DPorts = []*models.Port{{
Port: 0,
Protocol: models.PortProtocolANY,
}}
ctx = &newCtx
}
ctx.PolicyTrace("Tracing %s\n", ctx.String())
egressPolicy, err := p.ResolveL4EgressPolicy(ctx)
if 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
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"AllowsEgressRLocked",
"(",
"ctx",
"*",
"SearchContext",
")",
"api",
".",
"Decision",
"{",
"// Lack of DPorts in the SearchContext means L3-only search",
"if",
"len",
"(",
"ctx",
".",
"DPorts",
")",
"==",
"0",
"{",
"newC... | // AllowsEgressRLocked evaluates the policy repository for the provided search
// context and returns the verdict. If no matching policy allows for the
// connection, the request will be denied. The policy repository mutex must be
// held. | [
"AllowsEgressRLocked",
"evaluates",
"the",
"policy",
"repository",
"for",
"the",
"provided",
"search",
"context",
"and",
"returns",
"the",
"verdict",
".",
"If",
"no",
"matching",
"policy",
"allows",
"for",
"the",
"connection",
"the",
"request",
"will",
"be",
"de... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L228-L251 |
162,512 | cilium/cilium | pkg/policy/repository.go | SearchRLocked | func (p *Repository) SearchRLocked(labels labels.LabelArray) api.Rules {
result := api.Rules{}
for _, r := range p.rules {
if r.Labels.Contains(labels) {
result = append(result, &r.Rule)
}
}
return result
} | go | func (p *Repository) SearchRLocked(labels labels.LabelArray) api.Rules {
result := api.Rules{}
for _, r := range p.rules {
if r.Labels.Contains(labels) {
result = append(result, &r.Rule)
}
}
return result
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"SearchRLocked",
"(",
"labels",
"labels",
".",
"LabelArray",
")",
"api",
".",
"Rules",
"{",
"result",
":=",
"api",
".",
"Rules",
"{",
"}",
"\n\n",
"for",
"_",
",",
"r",
":=",
"range",
"p",
".",
"rules",
"{"... | // SearchRLocked searches the policy repository for rules which match the
// specified labels and will return an array of all rules which matched. | [
"SearchRLocked",
"searches",
"the",
"policy",
"repository",
"for",
"rules",
"which",
"match",
"the",
"specified",
"labels",
"and",
"will",
"return",
"an",
"array",
"of",
"all",
"rules",
"which",
"matched",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L255-L265 |
162,513 | cilium/cilium | pkg/policy/repository.go | AddListLocked | func (p *Repository) AddListLocked(rules api.Rules) (ruleSlice, uint64) {
newList := make(ruleSlice, len(rules))
for i := range rules {
newRule := &rule{
Rule: *rules[i],
metadata: newRuleMetadata(),
}
newList[i] = newRule
}
p.rules = append(p.rules, newList...)
p.BumpRevision()
metrics.PolicyCount.Add(float64(len(newList)))
return newList, p.GetRevision()
} | go | func (p *Repository) AddListLocked(rules api.Rules) (ruleSlice, uint64) {
newList := make(ruleSlice, len(rules))
for i := range rules {
newRule := &rule{
Rule: *rules[i],
metadata: newRuleMetadata(),
}
newList[i] = newRule
}
p.rules = append(p.rules, newList...)
p.BumpRevision()
metrics.PolicyCount.Add(float64(len(newList)))
return newList, p.GetRevision()
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"AddListLocked",
"(",
"rules",
"api",
".",
"Rules",
")",
"(",
"ruleSlice",
",",
"uint64",
")",
"{",
"newList",
":=",
"make",
"(",
"ruleSlice",
",",
"len",
"(",
"rules",
")",
")",
"\n",
"for",
"i",
":=",
"ra... | // AddListLocked inserts a rule into the policy repository with the repository already locked
// Expects that the entire rule list has already been sanitized. | [
"AddListLocked",
"inserts",
"a",
"rule",
"into",
"the",
"policy",
"repository",
"with",
"the",
"repository",
"already",
"locked",
"Expects",
"that",
"the",
"entire",
"rule",
"list",
"has",
"already",
"been",
"sanitized",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L305-L321 |
162,514 | cilium/cilium | pkg/policy/repository.go | removeIdentityFromRuleCaches | func (p *Repository) removeIdentityFromRuleCaches(identity *identity.Identity) *sync.WaitGroup {
var wg sync.WaitGroup
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
} | go | func (p *Repository) removeIdentityFromRuleCaches(identity *identity.Identity) *sync.WaitGroup {
var wg sync.WaitGroup
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
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"removeIdentityFromRuleCaches",
"(",
"identity",
"*",
"identity",
".",
"Identity",
")",
"*",
"sync",
".",
"WaitGroup",
"{",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"wg",
".",
"Add",
"(",
"len",
"(",
"p",
"... | // removeIdentityFromRuleCaches removes the identity from the selector cache
// in each rule in the repository.
//
// Returns a sync.WaitGroup that blocks until the policy operation is complete.
// The repository read lock must be held until the waitgroup is complete. | [
"removeIdentityFromRuleCaches",
"removes",
"the",
"identity",
"from",
"the",
"selector",
"cache",
"in",
"each",
"rule",
"in",
"the",
"repository",
".",
"Returns",
"a",
"sync",
".",
"WaitGroup",
"that",
"blocks",
"until",
"the",
"policy",
"operation",
"is",
"comp... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L328-L338 |
162,515 | cilium/cilium | pkg/policy/repository.go | LocalEndpointIdentityRemoved | func (p *Repository) LocalEndpointIdentityRemoved(identity *identity.Identity) {
go func() {
scopedLog := log.WithField(logfields.Identity, identity)
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")
}()
} | go | func (p *Repository) LocalEndpointIdentityRemoved(identity *identity.Identity) {
go func() {
scopedLog := log.WithField(logfields.Identity, identity)
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")
}()
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"LocalEndpointIdentityRemoved",
"(",
"identity",
"*",
"identity",
".",
"Identity",
")",
"{",
"go",
"func",
"(",
")",
"{",
"scopedLog",
":=",
"log",
".",
"WithField",
"(",
"logfields",
".",
"Identity",
",",
"identit... | // LocalEndpointIdentityRemoved handles local identity removal events to
// remove references from rules in the repository to the specified identity. | [
"LocalEndpointIdentityRemoved",
"handles",
"local",
"identity",
"removal",
"events",
"to",
"remove",
"references",
"from",
"rules",
"in",
"the",
"repository",
"to",
"the",
"specified",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L347-L357 |
162,516 | cilium/cilium | pkg/policy/repository.go | AddList | func (p *Repository) AddList(rules api.Rules) (ruleSlice, uint64) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
return p.AddListLocked(rules)
} | go | func (p *Repository) AddList(rules api.Rules) (ruleSlice, uint64) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
return p.AddListLocked(rules)
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"AddList",
"(",
"rules",
"api",
".",
"Rules",
")",
"(",
"ruleSlice",
",",
"uint64",
")",
"{",
"p",
".",
"Mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"Unlock",
"(",
")",
"\n",
"... | // AddList inserts a rule into the policy repository. It is used for
// unit-testing purposes only. | [
"AddList",
"inserts",
"a",
"rule",
"into",
"the",
"policy",
"repository",
".",
"It",
"is",
"used",
"for",
"unit",
"-",
"testing",
"purposes",
"only",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L361-L365 |
162,517 | cilium/cilium | pkg/policy/repository.go | UpdateRulesEndpointsCaches | func (r ruleSlice) UpdateRulesEndpointsCaches(endpointsToBumpRevision *EndpointSet, endpointsToRegenerate *IDSet, policySelectionWG *sync.WaitGroup) {
// No need to check whether endpoints need to be regenerated here since we
// will unconditionally regenerate all endpoints later.
if !option.Config.SelectiveRegeneration {
return
}
endpointsToBumpRevision.ForEach(policySelectionWG, func(epp Endpoint) {
endpointSelected, err := r.updateEndpointsCaches(epp, endpointsToRegenerate)
// 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 not determine what to do for the
// endpoint). This is usually the case when the endpoint is no longer
// alive (i.e., it has been marked to be deleted).
if endpointSelected || err != nil {
if err != nil {
log.WithError(err).Debug("could not determine whether endpoint was selected by rule")
}
endpointsToBumpRevision.Delete(epp)
}
})
} | go | func (r ruleSlice) UpdateRulesEndpointsCaches(endpointsToBumpRevision *EndpointSet, endpointsToRegenerate *IDSet, policySelectionWG *sync.WaitGroup) {
// No need to check whether endpoints need to be regenerated here since we
// will unconditionally regenerate all endpoints later.
if !option.Config.SelectiveRegeneration {
return
}
endpointsToBumpRevision.ForEach(policySelectionWG, func(epp Endpoint) {
endpointSelected, err := r.updateEndpointsCaches(epp, endpointsToRegenerate)
// 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 not determine what to do for the
// endpoint). This is usually the case when the endpoint is no longer
// alive (i.e., it has been marked to be deleted).
if endpointSelected || err != nil {
if err != nil {
log.WithError(err).Debug("could not determine whether endpoint was selected by rule")
}
endpointsToBumpRevision.Delete(epp)
}
})
} | [
"func",
"(",
"r",
"ruleSlice",
")",
"UpdateRulesEndpointsCaches",
"(",
"endpointsToBumpRevision",
"*",
"EndpointSet",
",",
"endpointsToRegenerate",
"*",
"IDSet",
",",
"policySelectionWG",
"*",
"sync",
".",
"WaitGroup",
")",
"{",
"// No need to check whether endpoints need... | // UpdateRulesEndpointsCaches updates the caches within each rule in r that
// specify whether the rule selects the endpoints in eps. If any rule matches
// the endpoints, it is added to the provided IDSet, and removed from the
// provided EndpointSet. The provided WaitGroup is signaled for a given endpoint
// when it is finished being processed. | [
"UpdateRulesEndpointsCaches",
"updates",
"the",
"caches",
"within",
"each",
"rule",
"in",
"r",
"that",
"specify",
"whether",
"the",
"rule",
"selects",
"the",
"endpoints",
"in",
"eps",
".",
"If",
"any",
"rule",
"matches",
"the",
"endpoints",
"it",
"is",
"added"... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L372-L396 |
162,518 | cilium/cilium | pkg/policy/repository.go | DeleteByLabelsLocked | func (p *Repository) DeleteByLabelsLocked(labels labels.LabelArray) (ruleSlice, uint64, int) {
deleted := 0
new := p.rules[:0]
deletedRules := ruleSlice{}
for _, r := range p.rules {
if !r.Labels.Contains(labels) {
new = append(new, r)
} else {
deletedRules = append(deletedRules, r)
deleted++
}
}
if deleted > 0 {
p.BumpRevision()
p.rules = new
metrics.PolicyCount.Sub(float64(deleted))
}
return deletedRules, p.GetRevision(), deleted
} | go | func (p *Repository) DeleteByLabelsLocked(labels labels.LabelArray) (ruleSlice, uint64, int) {
deleted := 0
new := p.rules[:0]
deletedRules := ruleSlice{}
for _, r := range p.rules {
if !r.Labels.Contains(labels) {
new = append(new, r)
} else {
deletedRules = append(deletedRules, r)
deleted++
}
}
if deleted > 0 {
p.BumpRevision()
p.rules = new
metrics.PolicyCount.Sub(float64(deleted))
}
return deletedRules, p.GetRevision(), deleted
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"DeleteByLabelsLocked",
"(",
"labels",
"labels",
".",
"LabelArray",
")",
"(",
"ruleSlice",
",",
"uint64",
",",
"int",
")",
"{",
"deleted",
":=",
"0",
"\n",
"new",
":=",
"p",
".",
"rules",
"[",
":",
"0",
"]",
... | // DeleteByLabelsLocked deletes all rules in the policy repository which
// contain the specified labels. Returns the revision of the policy repository
// after deleting the rules, as well as now many rules were deleted. | [
"DeleteByLabelsLocked",
"deletes",
"all",
"rules",
"in",
"the",
"policy",
"repository",
"which",
"contain",
"the",
"specified",
"labels",
".",
"Returns",
"the",
"revision",
"of",
"the",
"policy",
"repository",
"after",
"deleting",
"the",
"rules",
"as",
"well",
"... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L401-L423 |
162,519 | cilium/cilium | pkg/policy/repository.go | DeleteByLabels | func (p *Repository) DeleteByLabels(labels labels.LabelArray) (uint64, int) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
_, rev, numDeleted := p.DeleteByLabelsLocked(labels)
return rev, numDeleted
} | go | func (p *Repository) DeleteByLabels(labels labels.LabelArray) (uint64, int) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
_, rev, numDeleted := p.DeleteByLabelsLocked(labels)
return rev, numDeleted
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"DeleteByLabels",
"(",
"labels",
"labels",
".",
"LabelArray",
")",
"(",
"uint64",
",",
"int",
")",
"{",
"p",
".",
"Mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"Unlock",
"(",
")",
... | // DeleteByLabels deletes all rules in the policy repository which contain the
// specified labels | [
"DeleteByLabels",
"deletes",
"all",
"rules",
"in",
"the",
"policy",
"repository",
"which",
"contain",
"the",
"specified",
"labels"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L427-L432 |
162,520 | cilium/cilium | pkg/policy/repository.go | JSONMarshalRules | func JSONMarshalRules(rules api.Rules) string {
b, err := json.MarshalIndent(rules, "", " ")
if err != nil {
return err.Error()
}
return string(b)
} | go | func JSONMarshalRules(rules api.Rules) string {
b, err := json.MarshalIndent(rules, "", " ")
if err != nil {
return err.Error()
}
return string(b)
} | [
"func",
"JSONMarshalRules",
"(",
"rules",
"api",
".",
"Rules",
")",
"string",
"{",
"b",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"rules",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
".",
... | // JSONMarshalRules returns a slice of policy rules as string in JSON
// representation | [
"JSONMarshalRules",
"returns",
"a",
"slice",
"of",
"policy",
"rules",
"as",
"string",
"in",
"JSON",
"representation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L436-L442 |
162,521 | cilium/cilium | pkg/policy/repository.go | GetJSON | func (p *Repository) GetJSON() string {
p.Mutex.RLock()
defer p.Mutex.RUnlock()
result := api.Rules{}
for _, r := range p.rules {
result = append(result, &r.Rule)
}
return JSONMarshalRules(result)
} | go | func (p *Repository) GetJSON() string {
p.Mutex.RLock()
defer p.Mutex.RUnlock()
result := api.Rules{}
for _, r := range p.rules {
result = append(result, &r.Rule)
}
return JSONMarshalRules(result)
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"GetJSON",
"(",
")",
"string",
"{",
"p",
".",
"Mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"result",
":=",
"api",
".",
"Rules",
"{",
"}",
"\n",
"f... | // GetJSON returns all rules of the policy repository as string in JSON
// representation | [
"GetJSON",
"returns",
"all",
"rules",
"of",
"the",
"policy",
"repository",
"as",
"string",
"in",
"JSON",
"representation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L446-L456 |
162,522 | cilium/cilium | pkg/policy/repository.go | GetRulesMatching | func (p *Repository) GetRulesMatching(labels labels.LabelArray) (ingressMatch bool, egressMatch bool) {
ingressMatch = false
egressMatch = false
for _, r := range p.rules {
rulesMatch := r.EndpointSelector.Matches(labels)
if rulesMatch {
if len(r.Ingress) > 0 {
ingressMatch = true
}
if len(r.Egress) > 0 {
egressMatch = true
}
}
if ingressMatch && egressMatch {
return
}
}
return
} | go | func (p *Repository) GetRulesMatching(labels labels.LabelArray) (ingressMatch bool, egressMatch bool) {
ingressMatch = false
egressMatch = false
for _, r := range p.rules {
rulesMatch := r.EndpointSelector.Matches(labels)
if rulesMatch {
if len(r.Ingress) > 0 {
ingressMatch = true
}
if len(r.Egress) > 0 {
egressMatch = true
}
}
if ingressMatch && egressMatch {
return
}
}
return
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"GetRulesMatching",
"(",
"labels",
"labels",
".",
"LabelArray",
")",
"(",
"ingressMatch",
"bool",
",",
"egressMatch",
"bool",
")",
"{",
"ingressMatch",
"=",
"false",
"\n",
"egressMatch",
"=",
"false",
"\n",
"for",
... | // GetRulesMatching returns whether any of the rules in a repository contain a
// rule with labels matching the labels in the provided LabelArray.
//
// Must be called with p.Mutex held | [
"GetRulesMatching",
"returns",
"whether",
"any",
"of",
"the",
"rules",
"in",
"a",
"repository",
"contain",
"a",
"rule",
"with",
"labels",
"matching",
"the",
"labels",
"in",
"the",
"provided",
"LabelArray",
".",
"Must",
"be",
"called",
"with",
"p",
".",
"Mute... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L462-L481 |
162,523 | cilium/cilium | pkg/policy/repository.go | getMatchingRules | func (p *Repository) getMatchingRules(securityIdentity *identity.Identity) (ingressMatch bool, egressMatch bool, matchingRules ruleSlice) {
matchingRules = []*rule{}
ingressMatch = false
egressMatch = false
for _, r := range p.rules {
if ruleMatches := r.matches(securityIdentity); ruleMatches {
// Don't need to update whether ingressMatch is true if it already
// has been determined to be true - allows us to not have to check
// lenth of slice.
if !ingressMatch && len(r.Ingress) > 0 {
ingressMatch = true
}
if !egressMatch && len(r.Egress) > 0 {
egressMatch = true
}
matchingRules = append(matchingRules, r)
}
}
return
} | go | func (p *Repository) getMatchingRules(securityIdentity *identity.Identity) (ingressMatch bool, egressMatch bool, matchingRules ruleSlice) {
matchingRules = []*rule{}
ingressMatch = false
egressMatch = false
for _, r := range p.rules {
if ruleMatches := r.matches(securityIdentity); ruleMatches {
// Don't need to update whether ingressMatch is true if it already
// has been determined to be true - allows us to not have to check
// lenth of slice.
if !ingressMatch && len(r.Ingress) > 0 {
ingressMatch = true
}
if !egressMatch && len(r.Egress) > 0 {
egressMatch = true
}
matchingRules = append(matchingRules, r)
}
}
return
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"getMatchingRules",
"(",
"securityIdentity",
"*",
"identity",
".",
"Identity",
")",
"(",
"ingressMatch",
"bool",
",",
"egressMatch",
"bool",
",",
"matchingRules",
"ruleSlice",
")",
"{",
"matchingRules",
"=",
"[",
"]",
... | // getMatchingRules returns whether any of the rules in a repository contain a
// rule with labels matching the labels in the provided LabelArray, as well as
// a slice of all rules which match.
//
// Must be called with p.Mutex held | [
"getMatchingRules",
"returns",
"whether",
"any",
"of",
"the",
"rules",
"in",
"a",
"repository",
"contain",
"a",
"rule",
"with",
"labels",
"matching",
"the",
"labels",
"in",
"the",
"provided",
"LabelArray",
"as",
"well",
"as",
"a",
"slice",
"of",
"all",
"rule... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L488-L507 |
162,524 | cilium/cilium | pkg/policy/repository.go | Empty | func (p *Repository) Empty() bool {
p.Mutex.Lock()
defer p.Mutex.Unlock()
return p.NumRules() == 0
} | go | func (p *Repository) Empty() bool {
p.Mutex.Lock()
defer p.Mutex.Unlock()
return p.NumRules() == 0
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"Empty",
"(",
")",
"bool",
"{",
"p",
".",
"Mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NumRules",
"(",
")",
"==",
"0",
"\n",
"}... | // Empty returns 'true' if repository has no rules, 'false' otherwise.
//
// Must be called without p.Mutex held | [
"Empty",
"returns",
"true",
"if",
"repository",
"has",
"no",
"rules",
"false",
"otherwise",
".",
"Must",
"be",
"called",
"without",
"p",
".",
"Mutex",
"held"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L524-L528 |
162,525 | cilium/cilium | pkg/policy/repository.go | TranslateRules | func (p *Repository) TranslateRules(translator Translator) (*TranslationResult, error) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
result := &TranslationResult{}
for ruleIndex := range p.rules {
if err := translator.Translate(&p.rules[ruleIndex].Rule, result); err != nil {
return nil, err
}
}
return result, nil
} | go | func (p *Repository) TranslateRules(translator Translator) (*TranslationResult, error) {
p.Mutex.Lock()
defer p.Mutex.Unlock()
result := &TranslationResult{}
for ruleIndex := range p.rules {
if err := translator.Translate(&p.rules[ruleIndex].Rule, result); err != nil {
return nil, err
}
}
return result, nil
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"TranslateRules",
"(",
"translator",
"Translator",
")",
"(",
"*",
"TranslationResult",
",",
"error",
")",
"{",
"p",
".",
"Mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"Unlock",
"(",
"... | // TranslateRules traverses rules and applies provided translator to rules | [
"TranslateRules",
"traverses",
"rules",
"and",
"applies",
"provided",
"translator",
"to",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L538-L550 |
162,526 | cilium/cilium | pkg/policy/repository.go | BumpRevision | func (p *Repository) BumpRevision() {
metrics.PolicyRevision.Inc()
atomic.AddUint64(&p.revision, 1)
} | go | func (p *Repository) BumpRevision() {
metrics.PolicyRevision.Inc()
atomic.AddUint64(&p.revision, 1)
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"BumpRevision",
"(",
")",
"{",
"metrics",
".",
"PolicyRevision",
".",
"Inc",
"(",
")",
"\n",
"atomic",
".",
"AddUint64",
"(",
"&",
"p",
".",
"revision",
",",
"1",
")",
"\n",
"}"
] | // BumpRevision allows forcing policy regeneration | [
"BumpRevision",
"allows",
"forcing",
"policy",
"regeneration"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L553-L556 |
162,527 | cilium/cilium | pkg/policy/repository.go | GetRulesList | func (p *Repository) GetRulesList() *models.Policy {
p.Mutex.RLock()
defer p.Mutex.RUnlock()
lbls := labels.ParseSelectLabelArrayFromArray([]string{})
ruleList := p.SearchRLocked(lbls)
return &models.Policy{
Revision: int64(p.GetRevision()),
Policy: JSONMarshalRules(ruleList),
}
} | go | func (p *Repository) GetRulesList() *models.Policy {
p.Mutex.RLock()
defer p.Mutex.RUnlock()
lbls := labels.ParseSelectLabelArrayFromArray([]string{})
ruleList := p.SearchRLocked(lbls)
return &models.Policy{
Revision: int64(p.GetRevision()),
Policy: JSONMarshalRules(ruleList),
}
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"GetRulesList",
"(",
")",
"*",
"models",
".",
"Policy",
"{",
"p",
".",
"Mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"Mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"lbls",
":=",
"labels",
".",
"Pa... | // GetRulesList returns the current policy | [
"GetRulesList",
"returns",
"the",
"current",
"policy"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L559-L570 |
162,528 | cilium/cilium | pkg/policy/repository.go | ResolvePolicyLocked | func (p *Repository) ResolvePolicyLocked(securityIdentity *identity.Identity) (*SelectorPolicy, error) {
// First obtain whether policy applies in both traffic directions, as well
// as list of rules which actually select this endpoint. This allows us
// to not have to iterate through the entire rule list multiple times and
// perform the matching decision again when computing policy for each
// protocol layer, which is quite costly in terms of performance.
ingressEnabled, egressEnabled, matchingRules := p.computePolicyEnforcementAndRules(securityIdentity)
calculatedPolicy := &SelectorPolicy{
Revision: p.GetRevision(),
L4Policy: NewL4Policy(),
CIDRPolicy: NewCIDRPolicy(),
matchingRules: matchingRules,
IngressPolicyEnabled: ingressEnabled,
EgressPolicyEnabled: egressEnabled,
}
calculatedPolicy.IngressPolicyEnabled = ingressEnabled
calculatedPolicy.EgressPolicyEnabled = egressEnabled
labels := securityIdentity.LabelArray
ingressCtx := SearchContext{
To: labels,
rulesSelect: true,
skipL4RequirementsAggregation: false,
}
egressCtx := SearchContext{
From: labels,
rulesSelect: true,
skipL4RequirementsAggregation: false,
}
if option.Config.TracingEnabled() {
ingressCtx.Trace = TRACE_ENABLED
egressCtx.Trace = 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, err
}
calculatedPolicy.CIDRPolicy.Ingress = newCIDRIngressPolicy.Ingress
calculatedPolicy.L4Policy.Ingress = newL4IngressPolicy.Ingress
}
if egressEnabled {
newL4EgressPolicy, err := matchingRules.resolveL4EgressPolicy(&egressCtx, p.GetRevision())
if err != nil {
return nil, err
}
newCIDREgressPolicy := matchingRules.resolveCIDRPolicy(&egressCtx)
if err := newCIDREgressPolicy.Validate(); err != nil {
return nil, err
}
calculatedPolicy.CIDRPolicy.Egress = newCIDREgressPolicy.Egress
calculatedPolicy.L4Policy.Egress = newL4EgressPolicy.Egress
}
return calculatedPolicy, nil
} | go | func (p *Repository) ResolvePolicyLocked(securityIdentity *identity.Identity) (*SelectorPolicy, error) {
// First obtain whether policy applies in both traffic directions, as well
// as list of rules which actually select this endpoint. This allows us
// to not have to iterate through the entire rule list multiple times and
// perform the matching decision again when computing policy for each
// protocol layer, which is quite costly in terms of performance.
ingressEnabled, egressEnabled, matchingRules := p.computePolicyEnforcementAndRules(securityIdentity)
calculatedPolicy := &SelectorPolicy{
Revision: p.GetRevision(),
L4Policy: NewL4Policy(),
CIDRPolicy: NewCIDRPolicy(),
matchingRules: matchingRules,
IngressPolicyEnabled: ingressEnabled,
EgressPolicyEnabled: egressEnabled,
}
calculatedPolicy.IngressPolicyEnabled = ingressEnabled
calculatedPolicy.EgressPolicyEnabled = egressEnabled
labels := securityIdentity.LabelArray
ingressCtx := SearchContext{
To: labels,
rulesSelect: true,
skipL4RequirementsAggregation: false,
}
egressCtx := SearchContext{
From: labels,
rulesSelect: true,
skipL4RequirementsAggregation: false,
}
if option.Config.TracingEnabled() {
ingressCtx.Trace = TRACE_ENABLED
egressCtx.Trace = 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, err
}
calculatedPolicy.CIDRPolicy.Ingress = newCIDRIngressPolicy.Ingress
calculatedPolicy.L4Policy.Ingress = newL4IngressPolicy.Ingress
}
if egressEnabled {
newL4EgressPolicy, err := matchingRules.resolveL4EgressPolicy(&egressCtx, p.GetRevision())
if err != nil {
return nil, err
}
newCIDREgressPolicy := matchingRules.resolveCIDRPolicy(&egressCtx)
if err := newCIDREgressPolicy.Validate(); err != nil {
return nil, err
}
calculatedPolicy.CIDRPolicy.Egress = newCIDREgressPolicy.Egress
calculatedPolicy.L4Policy.Egress = newL4EgressPolicy.Egress
}
return calculatedPolicy, nil
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"ResolvePolicyLocked",
"(",
"securityIdentity",
"*",
"identity",
".",
"Identity",
")",
"(",
"*",
"SelectorPolicy",
",",
"error",
")",
"{",
"// First obtain whether policy applies in both traffic directions, as well",
"// as list o... | // ResolvePolicyLocked returns the EndpointPolicy for the provided set of
// labels against the set of rules in the repository, and the provided set of
// identities. If the policy cannot be generated due to conflicts at L4 or L7,
// returns an error.
//
// Must be performed while holding the Repository lock. | [
"ResolvePolicyLocked",
"returns",
"the",
"EndpointPolicy",
"for",
"the",
"provided",
"set",
"of",
"labels",
"against",
"the",
"set",
"of",
"rules",
"in",
"the",
"repository",
"and",
"the",
"provided",
"set",
"of",
"identities",
".",
"If",
"the",
"policy",
"can... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L578-L647 |
162,529 | cilium/cilium | pkg/policy/repository.go | computePolicyEnforcementAndRules | func (p *Repository) computePolicyEnforcementAndRules(securityIdentity *identity.Identity) (ingress bool, egress bool, matchingRules ruleSlice) {
lbls := securityIdentity.LabelArray
// Check if policy enforcement should be enabled at the daemon level.
switch GetPolicyEnabled() {
case option.AlwaysEnforce:
_, _, matchingRules = p.getMatchingRules(securityIdentity)
// If policy enforcement is enabled for the daemon, then it has to be
// enabled for the endpoint.
return true, true, matchingRules
case option.DefaultEnforcement:
ingress, egress, matchingRules = p.getMatchingRules(securityIdentity)
// If the endpoint has the reserved:init label, i.e. if it has not yet
// received any labels, always 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 isn't enabled, we do not enable policy
// enforcement for the endpoint. We don't care about returning any
// rules that match.
return false, false, nil
}
} | go | func (p *Repository) computePolicyEnforcementAndRules(securityIdentity *identity.Identity) (ingress bool, egress bool, matchingRules ruleSlice) {
lbls := securityIdentity.LabelArray
// Check if policy enforcement should be enabled at the daemon level.
switch GetPolicyEnabled() {
case option.AlwaysEnforce:
_, _, matchingRules = p.getMatchingRules(securityIdentity)
// If policy enforcement is enabled for the daemon, then it has to be
// enabled for the endpoint.
return true, true, matchingRules
case option.DefaultEnforcement:
ingress, egress, matchingRules = p.getMatchingRules(securityIdentity)
// If the endpoint has the reserved:init label, i.e. if it has not yet
// received any labels, always 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 isn't enabled, we do not enable policy
// enforcement for the endpoint. We don't care about returning any
// rules that match.
return false, false, nil
}
} | [
"func",
"(",
"p",
"*",
"Repository",
")",
"computePolicyEnforcementAndRules",
"(",
"securityIdentity",
"*",
"identity",
".",
"Identity",
")",
"(",
"ingress",
"bool",
",",
"egress",
"bool",
",",
"matchingRules",
"ruleSlice",
")",
"{",
"lbls",
":=",
"securityIdent... | // computePolicyEnforcementAndRules returns whether policy applies at ingress or ingress
// for the given set of labels, as well as a list of any rules which select
// the set of labels.
//
// Must be called with repo mutex held for reading. | [
"computePolicyEnforcementAndRules",
"returns",
"whether",
"policy",
"applies",
"at",
"ingress",
"or",
"ingress",
"for",
"the",
"given",
"set",
"of",
"labels",
"as",
"well",
"as",
"a",
"list",
"of",
"any",
"rules",
"which",
"select",
"the",
"set",
"of",
"labels... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/repository.go#L654-L681 |
162,530 | cilium/cilium | api/v1/server/restapi/policy/get_identity_id.go | NewGetIdentityID | func NewGetIdentityID(ctx *middleware.Context, handler GetIdentityIDHandler) *GetIdentityID {
return &GetIdentityID{Context: ctx, Handler: handler}
} | go | func NewGetIdentityID(ctx *middleware.Context, handler GetIdentityIDHandler) *GetIdentityID {
return &GetIdentityID{Context: ctx, Handler: handler}
} | [
"func",
"NewGetIdentityID",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetIdentityIDHandler",
")",
"*",
"GetIdentityID",
"{",
"return",
"&",
"GetIdentityID",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetIdentityID creates a new http.Handler for the get identity ID operation | [
"NewGetIdentityID",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"identity",
"ID",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity_id.go#L28-L30 |
162,531 | cilium/cilium | pkg/identity/reserved.go | AddReservedIdentity | func AddReservedIdentity(ni NumericIdentity, lbl string) {
identity := NewIdentity(ni, labels.Labels{lbl: labels.NewLabel(lbl, "", labels.LabelSourceReserved)})
// Pre-calculate the SHA256 hash.
identity.GetLabelsSHA256()
ReservedIdentityCache[ni] = identity
} | go | func AddReservedIdentity(ni NumericIdentity, lbl string) {
identity := NewIdentity(ni, labels.Labels{lbl: labels.NewLabel(lbl, "", labels.LabelSourceReserved)})
// Pre-calculate the SHA256 hash.
identity.GetLabelsSHA256()
ReservedIdentityCache[ni] = identity
} | [
"func",
"AddReservedIdentity",
"(",
"ni",
"NumericIdentity",
",",
"lbl",
"string",
")",
"{",
"identity",
":=",
"NewIdentity",
"(",
"ni",
",",
"labels",
".",
"Labels",
"{",
"lbl",
":",
"labels",
".",
"NewLabel",
"(",
"lbl",
",",
"\"",
"\"",
",",
"labels",... | // AddReservedIdentity adds the reserved numeric identity with the respective
// label into the map of reserved identity cache. | [
"AddReservedIdentity",
"adds",
"the",
"reserved",
"numeric",
"identity",
"with",
"the",
"respective",
"label",
"into",
"the",
"map",
"of",
"reserved",
"identity",
"cache",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/identity/reserved.go#L27-L32 |
162,532 | cilium/cilium | api/v1/server/restapi/endpoint/put_endpoint_id.go | NewPutEndpointID | func NewPutEndpointID(ctx *middleware.Context, handler PutEndpointIDHandler) *PutEndpointID {
return &PutEndpointID{Context: ctx, Handler: handler}
} | go | func NewPutEndpointID(ctx *middleware.Context, handler PutEndpointIDHandler) *PutEndpointID {
return &PutEndpointID{Context: ctx, Handler: handler}
} | [
"func",
"NewPutEndpointID",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"PutEndpointIDHandler",
")",
"*",
"PutEndpointID",
"{",
"return",
"&",
"PutEndpointID",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewPutEndpointID creates a new http.Handler for the put endpoint ID operation | [
"NewPutEndpointID",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"put",
"endpoint",
"ID",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/put_endpoint_id.go#L28-L30 |
162,533 | cilium/cilium | api/v1/health/server/restapi/cilium_health_api.go | NewCiliumHealthAPI | func NewCiliumHealthAPI(spec *loads.Document) *CiliumHealthAPI {
return &CiliumHealthAPI{
handlers: make(map[string]map[string]http.Handler),
formats: strfmt.Default,
defaultConsumes: "application/json",
defaultProduces: "application/json",
customConsumers: make(map[string]runtime.Consumer),
customProducers: make(map[string]runtime.Producer),
ServerShutdown: func() {},
spec: spec,
ServeError: errors.ServeError,
BasicAuthenticator: security.BasicAuth,
APIKeyAuthenticator: security.APIKeyAuth,
BearerAuthenticator: security.BearerAuth,
JSONConsumer: 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 GetHelloParams) middleware.Responder {
return middleware.NotImplemented("operation GetHello has not yet been implemented")
}),
ConnectivityGetStatusHandler: connectivity.GetStatusHandlerFunc(func(params connectivity.GetStatusParams) middleware.Responder {
return middleware.NotImplemented("operation ConnectivityGetStatus has not yet been implemented")
}),
ConnectivityPutStatusProbeHandler: connectivity.PutStatusProbeHandlerFunc(func(params connectivity.PutStatusProbeParams) middleware.Responder {
return middleware.NotImplemented("operation ConnectivityPutStatusProbe has not yet been implemented")
}),
}
} | go | func NewCiliumHealthAPI(spec *loads.Document) *CiliumHealthAPI {
return &CiliumHealthAPI{
handlers: make(map[string]map[string]http.Handler),
formats: strfmt.Default,
defaultConsumes: "application/json",
defaultProduces: "application/json",
customConsumers: make(map[string]runtime.Consumer),
customProducers: make(map[string]runtime.Producer),
ServerShutdown: func() {},
spec: spec,
ServeError: errors.ServeError,
BasicAuthenticator: security.BasicAuth,
APIKeyAuthenticator: security.APIKeyAuth,
BearerAuthenticator: security.BearerAuth,
JSONConsumer: 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 GetHelloParams) middleware.Responder {
return middleware.NotImplemented("operation GetHello has not yet been implemented")
}),
ConnectivityGetStatusHandler: connectivity.GetStatusHandlerFunc(func(params connectivity.GetStatusParams) middleware.Responder {
return middleware.NotImplemented("operation ConnectivityGetStatus has not yet been implemented")
}),
ConnectivityPutStatusProbeHandler: connectivity.PutStatusProbeHandlerFunc(func(params connectivity.PutStatusProbeParams) middleware.Responder {
return middleware.NotImplemented("operation ConnectivityPutStatusProbe has not yet been implemented")
}),
}
} | [
"func",
"NewCiliumHealthAPI",
"(",
"spec",
"*",
"loads",
".",
"Document",
")",
"*",
"CiliumHealthAPI",
"{",
"return",
"&",
"CiliumHealthAPI",
"{",
"handlers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"http",
".",
"Handler",
... | // NewCiliumHealthAPI creates a new CiliumHealth instance | [
"NewCiliumHealthAPI",
"creates",
"a",
"new",
"CiliumHealth",
"instance"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/cilium_health_api.go#L26-L55 |
162,534 | cilium/cilium | api/v1/health/server/restapi/cilium_health_api.go | Validate | func (o *CiliumHealthAPI) Validate() error {
var unregistered []string
if o.JSONConsumer == nil {
unregistered = append(unregistered, "JSONConsumer")
}
if o.JSONProducer == nil {
unregistered = append(unregistered, "JSONProducer")
}
if o.GetHealthzHandler == nil {
unregistered = append(unregistered, "GetHealthzHandler")
}
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.PutStatusProbeHandler")
}
if len(unregistered) > 0 {
return fmt.Errorf("missing registration: %s", strings.Join(unregistered, ", "))
}
return nil
} | go | func (o *CiliumHealthAPI) Validate() error {
var unregistered []string
if o.JSONConsumer == nil {
unregistered = append(unregistered, "JSONConsumer")
}
if o.JSONProducer == nil {
unregistered = append(unregistered, "JSONProducer")
}
if o.GetHealthzHandler == nil {
unregistered = append(unregistered, "GetHealthzHandler")
}
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.PutStatusProbeHandler")
}
if len(unregistered) > 0 {
return fmt.Errorf("missing registration: %s", strings.Join(unregistered, ", "))
}
return nil
} | [
"func",
"(",
"o",
"*",
"CiliumHealthAPI",
")",
"Validate",
"(",
")",
"error",
"{",
"var",
"unregistered",
"[",
"]",
"string",
"\n\n",
"if",
"o",
".",
"JSONConsumer",
"==",
"nil",
"{",
"unregistered",
"=",
"append",
"(",
"unregistered",
",",
"\"",
"\"",
... | // Validate validates the registrations in the CiliumHealthAPI | [
"Validate",
"validates",
"the",
"registrations",
"in",
"the",
"CiliumHealthAPI"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/cilium_health_api.go#L145-L177 |
162,535 | cilium/cilium | api/v1/health/server/restapi/cilium_health_api.go | Context | func (o *CiliumHealthAPI) Context() *middleware.Context {
if o.context == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | go | func (o *CiliumHealthAPI) Context() *middleware.Context {
if o.context == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | [
"func",
"(",
"o",
"*",
"CiliumHealthAPI",
")",
"Context",
"(",
")",
"*",
"middleware",
".",
"Context",
"{",
"if",
"o",
".",
"context",
"==",
"nil",
"{",
"o",
".",
"context",
"=",
"middleware",
".",
"NewRoutableContext",
"(",
"o",
".",
"spec",
",",
"o... | // Context returns the middleware context for the cilium health API | [
"Context",
"returns",
"the",
"middleware",
"context",
"for",
"the",
"cilium",
"health",
"API"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/cilium_health_api.go#L255-L261 |
162,536 | cilium/cilium | pkg/maps/ctmap/lookup.go | ToNetwork | func (k *CtKey4) ToNetwork() tuple.TupleKey {
n := *k
n.SourcePort = byteorder.HostToNetwork(n.SourcePort).(uint16)
n.DestPort = byteorder.HostToNetwork(n.DestPort).(uint16)
return &n
} | go | func (k *CtKey4) ToNetwork() tuple.TupleKey {
n := *k
n.SourcePort = byteorder.HostToNetwork(n.SourcePort).(uint16)
n.DestPort = byteorder.HostToNetwork(n.DestPort).(uint16)
return &n
} | [
"func",
"(",
"k",
"*",
"CtKey4",
")",
"ToNetwork",
"(",
")",
"tuple",
".",
"TupleKey",
"{",
"n",
":=",
"*",
"k",
"\n",
"n",
".",
"SourcePort",
"=",
"byteorder",
".",
"HostToNetwork",
"(",
"n",
".",
"SourcePort",
")",
".",
"(",
"uint16",
")",
"\n",
... | // ToNetwork converts CtKey4 ports to network byte order. | [
"ToNetwork",
"converts",
"CtKey4",
"ports",
"to",
"network",
"byte",
"order",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/ctmap/lookup.go#L37-L42 |
162,537 | cilium/cilium | pkg/maps/ctmap/lookup.go | Lookup | func Lookup(epname string, remoteAddr, localAddr string, proto u8proto.U8proto, ingress bool) (*CtEntry, error) {
key, err := createTupleKey(remoteAddr, localAddr, proto, ingress)
if err != nil {
return nil, err
}
_, ipv4 := key.(*CtKey4)
mapname := getMapName(epname, ipv4, proto)
m := bpf.GetMap(mapname)
if m == nil {
// Open the map and leave it open
m, err = bpf.OpenMap(mapname)
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
} | go | func Lookup(epname string, remoteAddr, localAddr string, proto u8proto.U8proto, ingress bool) (*CtEntry, error) {
key, err := createTupleKey(remoteAddr, localAddr, proto, ingress)
if err != nil {
return nil, err
}
_, ipv4 := key.(*CtKey4)
mapname := getMapName(epname, ipv4, proto)
m := bpf.GetMap(mapname)
if m == nil {
// Open the map and leave it open
m, err = bpf.OpenMap(mapname)
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
} | [
"func",
"Lookup",
"(",
"epname",
"string",
",",
"remoteAddr",
",",
"localAddr",
"string",
",",
"proto",
"u8proto",
".",
"U8proto",
",",
"ingress",
"bool",
")",
"(",
"*",
"CtEntry",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"createTupleKey",
"(",
... | // Lookup opens a conntrack map if necessary, and does a lookup on it with a key constructed from
// the parameters
// 'epname' is a 5-digit represenation of the endpoint ID if local maps
// are to be used, or "global" if global maps should be used. | [
"Lookup",
"opens",
"a",
"conntrack",
"map",
"if",
"necessary",
"and",
"does",
"a",
"lookup",
"on",
"it",
"with",
"a",
"key",
"constructed",
"from",
"the",
"parameters",
"epname",
"is",
"a",
"5",
"-",
"digit",
"represenation",
"of",
"the",
"endpoint",
"ID",... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/ctmap/lookup.go#L147-L171 |
162,538 | cilium/cilium | pkg/maps/ctmap/lookup.go | CloseLocalMaps | func CloseLocalMaps(mapname string) {
// only close local maps. Global map is kept open as long as cilium-agent is running.
if mapname != "global" {
// close IPv4 maps, if any
if m := getMapWithName(mapname, true, u8proto.TCP); m != nil {
m.Close()
}
if m := getMapWithName(mapname, true, u8proto.UDP); m != nil {
m.Close()
}
// close 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()
}
}
} | go | func CloseLocalMaps(mapname string) {
// only close local maps. Global map is kept open as long as cilium-agent is running.
if mapname != "global" {
// close IPv4 maps, if any
if m := getMapWithName(mapname, true, u8proto.TCP); m != nil {
m.Close()
}
if m := getMapWithName(mapname, true, u8proto.UDP); m != nil {
m.Close()
}
// close 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()
}
}
} | [
"func",
"CloseLocalMaps",
"(",
"mapname",
"string",
")",
"{",
"// only close local maps. Global map is kept open as long as cilium-agent is running.",
"if",
"mapname",
"!=",
"\"",
"\"",
"{",
"// close IPv4 maps, if any",
"if",
"m",
":=",
"getMapWithName",
"(",
"mapname",
",... | // CloseLocalMaps closes all local conntrack maps opened previously
// for lookup with the given 'mapname'. | [
"CloseLocalMaps",
"closes",
"all",
"local",
"conntrack",
"maps",
"opened",
"previously",
"for",
"lookup",
"with",
"the",
"given",
"mapname",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/ctmap/lookup.go#L179-L198 |
162,539 | cilium/cilium | pkg/policy/rule.go | rulePortsCoverSearchContext | func rulePortsCoverSearchContext(ports []api.PortProtocol, ctx *SearchContext) bool {
if len(ctx.DPorts) == 0 {
return true
}
for _, p := range ports {
for _, dp := range ctx.DPorts {
tracePort := api.PortProtocol{
Port: fmt.Sprintf("%d", dp.Port),
Protocol: api.L4Proto(dp.Protocol),
}
if p.Covers(tracePort) {
return true
}
}
}
return false
} | go | func rulePortsCoverSearchContext(ports []api.PortProtocol, ctx *SearchContext) bool {
if len(ctx.DPorts) == 0 {
return true
}
for _, p := range ports {
for _, dp := range ctx.DPorts {
tracePort := api.PortProtocol{
Port: fmt.Sprintf("%d", dp.Port),
Protocol: api.L4Proto(dp.Protocol),
}
if p.Covers(tracePort) {
return true
}
}
}
return false
} | [
"func",
"rulePortsCoverSearchContext",
"(",
"ports",
"[",
"]",
"api",
".",
"PortProtocol",
",",
"ctx",
"*",
"SearchContext",
")",
"bool",
"{",
"if",
"len",
"(",
"ctx",
".",
"DPorts",
")",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"for",
"_",
... | // portRulesCoverContext determines whether L4 portions of rules cover the
// specified port models.
//
// Returns true if the list of ports is 0, or the rules match the ports. | [
"portRulesCoverContext",
"determines",
"whether",
"L4",
"portions",
"of",
"rules",
"cover",
"the",
"specified",
"port",
"models",
".",
"Returns",
"true",
"if",
"the",
"list",
"of",
"ports",
"is",
"0",
"or",
"the",
"rules",
"match",
"the",
"ports",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/rule.go#L209-L225 |
162,540 | cilium/cilium | pkg/policy/rule.go | resolveCIDRPolicy | func (r *rule) resolveCIDRPolicy(ctx *SearchContext, state *traceState, result *CIDRPolicy) *CIDRPolicy {
// Don't select rule if it doesn't apply to the given context.
if !ctx.rulesSelect {
if !r.EndpointSelector.Matches(ctx.To) {
state.unSelectRule(ctx, ctx.To, r)
return nil
}
}
state.selectRule(ctx, r)
found := 0
for _, ingressRule := range r.Ingress {
// TODO (ianvernon): GH-1658
var allCIDRs []api.CIDR
allCIDRs = append(allCIDRs, ingressRule.FromCIDR...)
allCIDRs = append(allCIDRs, api.ComputeResultantCIDRSet(ingressRule.FromCIDRSet)...)
// CIDR + L4 rules are handled via mergeIngress(),
// skip them here.
if len(allCIDRs) > 0 && len(ingressRule.ToPorts) > 0 {
continue
}
if cnt := mergeCIDR(ctx, "Ingress", allCIDRs, r.Labels, &result.Ingress); cnt > 0 {
found += cnt
}
}
// CIDR egress policy is used for visibility of desired state in
// the API and for determining which prefix lengths are available,
// however it does not determine the actual CIDRs in 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
// this function, we count the CIDR+L4 policy in the
// desired egress CIDR policy here as well. This ensures
// proper computation of IPcache prefix lengths.
if cnt := mergeCIDR(ctx, "Egress", allCIDRs, r.Labels, &result.Egress); cnt > 0 {
found += cnt
}
}
if found > 0 {
return result
}
ctx.PolicyTrace(" No L3 rules\n")
return nil
} | go | func (r *rule) resolveCIDRPolicy(ctx *SearchContext, state *traceState, result *CIDRPolicy) *CIDRPolicy {
// Don't select rule if it doesn't apply to the given context.
if !ctx.rulesSelect {
if !r.EndpointSelector.Matches(ctx.To) {
state.unSelectRule(ctx, ctx.To, r)
return nil
}
}
state.selectRule(ctx, r)
found := 0
for _, ingressRule := range r.Ingress {
// TODO (ianvernon): GH-1658
var allCIDRs []api.CIDR
allCIDRs = append(allCIDRs, ingressRule.FromCIDR...)
allCIDRs = append(allCIDRs, api.ComputeResultantCIDRSet(ingressRule.FromCIDRSet)...)
// CIDR + L4 rules are handled via mergeIngress(),
// skip them here.
if len(allCIDRs) > 0 && len(ingressRule.ToPorts) > 0 {
continue
}
if cnt := mergeCIDR(ctx, "Ingress", allCIDRs, r.Labels, &result.Ingress); cnt > 0 {
found += cnt
}
}
// CIDR egress policy is used for visibility of desired state in
// the API and for determining which prefix lengths are available,
// however it does not determine the actual CIDRs in 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
// this function, we count the CIDR+L4 policy in the
// desired egress CIDR policy here as well. This ensures
// proper computation of IPcache prefix lengths.
if cnt := mergeCIDR(ctx, "Egress", allCIDRs, r.Labels, &result.Egress); cnt > 0 {
found += cnt
}
}
if found > 0 {
return result
}
ctx.PolicyTrace(" No L3 rules\n")
return nil
} | [
"func",
"(",
"r",
"*",
"rule",
")",
"resolveCIDRPolicy",
"(",
"ctx",
"*",
"SearchContext",
",",
"state",
"*",
"traceState",
",",
"result",
"*",
"CIDRPolicy",
")",
"*",
"CIDRPolicy",
"{",
"// Don't select rule if it doesn't apply to the given context.",
"if",
"!",
... | // resolveCIDRPolicy inserts the CIDRs from the specified rule into result if
// the rule corresponds to the current SearchContext. It returns the resultant
// CIDRPolicy containing the added ingress and egress CIDRs. If no CIDRs are
// added to result, a nil CIDRPolicy is returned. | [
"resolveCIDRPolicy",
"inserts",
"the",
"CIDRs",
"from",
"the",
"specified",
"rule",
"into",
"result",
"if",
"the",
"rule",
"corresponds",
"to",
"the",
"current",
"SearchContext",
".",
"It",
"returns",
"the",
"resultant",
"CIDRPolicy",
"containing",
"the",
"added",... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/rule.go#L407-L460 |
162,541 | cilium/cilium | pkg/policy/rule.go | canReachIngress | func (r *rule) canReachIngress(ctx *SearchContext, state *traceState) api.Decision {
if !ctx.rulesSelect {
if !r.EndpointSelector.Matches(ctx.To) {
state.unSelectRule(ctx, ctx.To, r)
return api.Undecided
}
}
state.selectRule(ctx, r)
// If a requirement explicitly denies access, we can return.
if r.meetsRequirementsIngress(ctx, state) == api.Denied {
return api.Denied
}
return r.canReachFromEndpoints(ctx, state)
} | go | func (r *rule) canReachIngress(ctx *SearchContext, state *traceState) api.Decision {
if !ctx.rulesSelect {
if !r.EndpointSelector.Matches(ctx.To) {
state.unSelectRule(ctx, ctx.To, r)
return api.Undecided
}
}
state.selectRule(ctx, r)
// If a requirement explicitly denies access, we can return.
if r.meetsRequirementsIngress(ctx, state) == api.Denied {
return api.Denied
}
return r.canReachFromEndpoints(ctx, state)
} | [
"func",
"(",
"r",
"*",
"rule",
")",
"canReachIngress",
"(",
"ctx",
"*",
"SearchContext",
",",
"state",
"*",
"traceState",
")",
"api",
".",
"Decision",
"{",
"if",
"!",
"ctx",
".",
"rulesSelect",
"{",
"if",
"!",
"r",
".",
"EndpointSelector",
".",
"Matche... | // canReachIngress returns the decision as to whether the set of labels specified
// in ctx.From match with the label selectors specified in the ingress rules
// contained within r. | [
"canReachIngress",
"returns",
"the",
"decision",
"as",
"to",
"whether",
"the",
"set",
"of",
"labels",
"specified",
"in",
"ctx",
".",
"From",
"match",
"with",
"the",
"label",
"selectors",
"specified",
"in",
"the",
"ingress",
"rules",
"contained",
"within",
"r",... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/rule.go#L465-L482 |
162,542 | cilium/cilium | pkg/policy/rule.go | meetsRequirementsIngress | func (r *rule) meetsRequirementsIngress(ctx *SearchContext, state *traceState) api.Decision {
for _, r := range r.Ingress {
for _, sel := range r.FromRequires {
ctx.PolicyTrace(" 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
} | go | func (r *rule) meetsRequirementsIngress(ctx *SearchContext, state *traceState) api.Decision {
for _, r := range r.Ingress {
for _, sel := range r.FromRequires {
ctx.PolicyTrace(" 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
} | [
"func",
"(",
"r",
"*",
"rule",
")",
"meetsRequirementsIngress",
"(",
"ctx",
"*",
"SearchContext",
",",
"state",
"*",
"traceState",
")",
"api",
".",
"Decision",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"r",
".",
"Ingress",
"{",
"for",
"_",
",",
"sel"... | // meetsRequirementsIngress returns whether the labels in ctx.From do not
// meet the requirements in the provided rule. If a rule does meet the
// requirements in the rule, that does not mean that the rule allows traffic
// from the labels in ctx.From, merely that the rule does not deny it. | [
"meetsRequirementsIngress",
"returns",
"whether",
"the",
"labels",
"in",
"ctx",
".",
"From",
"do",
"not",
"meet",
"the",
"requirements",
"in",
"the",
"provided",
"rule",
".",
"If",
"a",
"rule",
"does",
"meet",
"the",
"requirements",
"in",
"the",
"rule",
"tha... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/rule.go#L533-L546 |
162,543 | cilium/cilium | pkg/policy/rule.go | meetsRequirementsEgress | func (r *rule) meetsRequirementsEgress(ctx *SearchContext, state *traceState) api.Decision {
for _, r := range r.Egress {
for _, sel := range r.ToRequires {
ctx.PolicyTrace(" 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
} | go | func (r *rule) meetsRequirementsEgress(ctx *SearchContext, state *traceState) api.Decision {
for _, r := range r.Egress {
for _, sel := range r.ToRequires {
ctx.PolicyTrace(" 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
} | [
"func",
"(",
"r",
"*",
"rule",
")",
"meetsRequirementsEgress",
"(",
"ctx",
"*",
"SearchContext",
",",
"state",
"*",
"traceState",
")",
"api",
".",
"Decision",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"r",
".",
"Egress",
"{",
"for",
"_",
",",
"sel",
... | // meetsRequirementsEgress returns whether the labels in ctx.To do not
// meet the requirements in the provided rule. If a rule does meet the
// requirements in the rule, that does not mean that the rule allows traffic
// from the labels in ctx.To, merely that the rule does not deny it. | [
"meetsRequirementsEgress",
"returns",
"whether",
"the",
"labels",
"in",
"ctx",
".",
"To",
"do",
"not",
"meet",
"the",
"requirements",
"in",
"the",
"provided",
"rule",
".",
"If",
"a",
"rule",
"does",
"meet",
"the",
"requirements",
"in",
"the",
"rule",
"that",... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/rule.go#L594-L607 |
162,544 | cilium/cilium | pkg/policy/api/decision.go | String | func (d Decision) String() string {
if v, exists := decisionToString[d]; exists {
return v
}
return ""
} | go | func (d Decision) String() string {
if v, exists := decisionToString[d]; exists {
return v
}
return ""
} | [
"func",
"(",
"d",
"Decision",
")",
"String",
"(",
")",
"string",
"{",
"if",
"v",
",",
"exists",
":=",
"decisionToString",
"[",
"d",
"]",
";",
"exists",
"{",
"return",
"v",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // String returns the decision in human readable format | [
"String",
"returns",
"the",
"decision",
"in",
"human",
"readable",
"format"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/decision.go#L47-L52 |
162,545 | cilium/cilium | pkg/policy/api/decision.go | UnmarshalJSON | func (d *Decision) UnmarshalJSON(b []byte) error {
if d == nil {
d = new(Decision)
}
if len(b) <= len(`""`) {
return fmt.Errorf("invalid decision '%s'", string(b))
}
if v, exists := stringToDecision[string(b[1:len(b)-1])]; exists {
*d = v
return nil
}
return fmt.Errorf("unknown '%s' decision", string(b))
} | go | func (d *Decision) UnmarshalJSON(b []byte) error {
if d == nil {
d = new(Decision)
}
if len(b) <= len(`""`) {
return fmt.Errorf("invalid decision '%s'", string(b))
}
if v, exists := stringToDecision[string(b[1:len(b)-1])]; exists {
*d = v
return nil
}
return fmt.Errorf("unknown '%s' decision", string(b))
} | [
"func",
"(",
"d",
"*",
"Decision",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"d",
"==",
"nil",
"{",
"d",
"=",
"new",
"(",
"Decision",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"b",
")",
"<=",
"len",
"(",
"`\"\"`... | // UnmarshalJSON parses a JSON formatted buffer and returns a decision | [
"UnmarshalJSON",
"parses",
"a",
"JSON",
"formatted",
"buffer",
"and",
"returns",
"a",
"decision"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/decision.go#L55-L68 |
162,546 | cilium/cilium | pkg/policy/api/decision.go | MarshalJSON | func (d Decision) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`"%s"`, d)), nil
} | go | func (d Decision) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`"%s"`, d)), nil
} | [
"func",
"(",
"d",
"Decision",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"`\"%s\"`",
",",
"d",
")",
")",
",",
"nil",
"\n",
"}"
] | // MarshalJSON returns the decision as JSON formatted buffer | [
"MarshalJSON",
"returns",
"the",
"decision",
"as",
"JSON",
"formatted",
"buffer"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/decision.go#L71-L73 |
162,547 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | SetSocketOptions | func (f *sessionUDPFactory) SetSocketOptions(conn *net.UDPConn) error {
// Set up the raw socket for sending responses.
// - Must use a raw UDP socket for sending responses so that we can send
// from a specific port without binding to it.
// - The raw UDP socket must be bound to a specific IP address to prevent
// it receiving ALL UDP packets on the host.
// - We use oob data to override the source IP address 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() {
rawconn4 = bindUDP("127.0.0.1") // raw socket for sending IPv4
rawconn6 = bindUDP("::1") // raw socket for sending IPv6
})
if rawconn4 == nil || rawconn6 == nil {
return fmt.Errorf("Unable to open raw UDP sockets for DNS Proxy")
}
return nil
} | go | func (f *sessionUDPFactory) SetSocketOptions(conn *net.UDPConn) error {
// Set up the raw socket for sending responses.
// - Must use a raw UDP socket for sending responses so that we can send
// from a specific port without binding to it.
// - The raw UDP socket must be bound to a specific IP address to prevent
// it receiving ALL UDP packets on the host.
// - We use oob data to override the source IP address 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() {
rawconn4 = bindUDP("127.0.0.1") // raw socket for sending IPv4
rawconn6 = bindUDP("::1") // raw socket for sending IPv6
})
if rawconn4 == nil || rawconn6 == nil {
return fmt.Errorf("Unable to open raw UDP sockets for DNS Proxy")
}
return nil
} | [
"func",
"(",
"f",
"*",
"sessionUDPFactory",
")",
"SetSocketOptions",
"(",
"conn",
"*",
"net",
".",
"UDPConn",
")",
"error",
"{",
"// Set up the raw socket for sending responses.",
"// - Must use a raw UDP socket for sending responses so that we can send",
"// from a specific po... | // SetSocketOptions set's up 'conn' to be used with a SessionUDP. | [
"SetSocketOptions",
"set",
"s",
"up",
"conn",
"to",
"be",
"used",
"with",
"a",
"SessionUDP",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L117-L136 |
162,548 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | InitPool | func (f *sessionUDPFactory) InitPool(msgSize int) {
f.udpPool.New = func() interface{} {
return &sessionUDP{
f: f,
m: make([]byte, msgSize),
oob: make([]byte, udpOOBSize),
}
}
} | go | func (f *sessionUDPFactory) InitPool(msgSize int) {
f.udpPool.New = func() interface{} {
return &sessionUDP{
f: f,
m: make([]byte, msgSize),
oob: make([]byte, udpOOBSize),
}
}
} | [
"func",
"(",
"f",
"*",
"sessionUDPFactory",
")",
"InitPool",
"(",
"msgSize",
"int",
")",
"{",
"f",
".",
"udpPool",
".",
"New",
"=",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"&",
"sessionUDP",
"{",
"f",
":",
"f",
",",
"m",
":",
"mak... | // InitPool initializes a pool of buffers to be used with SessionUDP. | [
"InitPool",
"initializes",
"a",
"pool",
"of",
"buffers",
"to",
"be",
"used",
"with",
"SessionUDP",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L139-L147 |
162,549 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | ReadRequest | func (f *sessionUDPFactory) ReadRequest(conn *net.UDPConn) ([]byte, dns.SessionUDP, error) {
s := f.udpPool.Get().(*sessionUDP)
n, oobn, _, raddr, err := conn.ReadMsgUDP(s.m, s.oob)
if err != nil {
s.Discard()
return nil, nil, err
}
s.conn = conn
s.raddr = raddr
s.m = s.m[:n] // Re-slice to the actual 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
} | go | func (f *sessionUDPFactory) ReadRequest(conn *net.UDPConn) ([]byte, dns.SessionUDP, error) {
s := f.udpPool.Get().(*sessionUDP)
n, oobn, _, raddr, err := conn.ReadMsgUDP(s.m, s.oob)
if err != nil {
s.Discard()
return nil, nil, err
}
s.conn = conn
s.raddr = raddr
s.m = s.m[:n] // Re-slice to the actual 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
} | [
"func",
"(",
"f",
"*",
"sessionUDPFactory",
")",
"ReadRequest",
"(",
"conn",
"*",
"net",
".",
"UDPConn",
")",
"(",
"[",
"]",
"byte",
",",
"dns",
".",
"SessionUDP",
",",
"error",
")",
"{",
"s",
":=",
"f",
".",
"udpPool",
".",
"Get",
"(",
")",
".",... | // ReadRequest reads a single request from 'conn' and returns the request context | [
"ReadRequest",
"reads",
"a",
"single",
"request",
"from",
"conn",
"and",
"returns",
"the",
"request",
"context"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L150-L167 |
162,550 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | Discard | func (s *sessionUDP) Discard() {
s.conn = nil
s.raddr = nil
s.laddr = nil
s.m = s.m[:cap(s.m)]
s.oob = s.oob[:cap(s.oob)]
s.f.udpPool.Put(s)
} | go | func (s *sessionUDP) Discard() {
s.conn = nil
s.raddr = nil
s.laddr = nil
s.m = s.m[:cap(s.m)]
s.oob = s.oob[:cap(s.oob)]
s.f.udpPool.Put(s)
} | [
"func",
"(",
"s",
"*",
"sessionUDP",
")",
"Discard",
"(",
")",
"{",
"s",
".",
"conn",
"=",
"nil",
"\n",
"s",
".",
"raddr",
"=",
"nil",
"\n",
"s",
".",
"laddr",
"=",
"nil",
"\n",
"s",
".",
"m",
"=",
"s",
".",
"m",
"[",
":",
"cap",
"(",
"s"... | // Discard returns 's' to the factory pool | [
"Discard",
"returns",
"s",
"to",
"the",
"factory",
"pool"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L170-L178 |
162,551 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | WriteResponse | func (s *sessionUDP) WriteResponse(b []byte) (int, error) {
// Must give the UDP header to get the source port right.
// Reuse the msg buffer, figure out if golang can do gatter-scather IO
// with raw sockets?
bb := bytes.NewBuffer(s.m[:0])
binary.Write(bb, binary.BigEndian, uint16(s.laddr.Port))
binary.Write(bb, binary.BigEndian, uint16(s.raddr.Port))
binary.Write(bb, binary.BigEndian, uint16(8+len(b)))
binary.Write(bb, binary.BigEndian, uint16(0)) // checksum
bb.Write(b)
buf := bb.Bytes()
var n int
var err error
dst := net.IPAddr{
IP: s.raddr.IP,
}
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
} | go | func (s *sessionUDP) WriteResponse(b []byte) (int, error) {
// Must give the UDP header to get the source port right.
// Reuse the msg buffer, figure out if golang can do gatter-scather IO
// with raw sockets?
bb := bytes.NewBuffer(s.m[:0])
binary.Write(bb, binary.BigEndian, uint16(s.laddr.Port))
binary.Write(bb, binary.BigEndian, uint16(s.raddr.Port))
binary.Write(bb, binary.BigEndian, uint16(8+len(b)))
binary.Write(bb, binary.BigEndian, uint16(0)) // checksum
bb.Write(b)
buf := bb.Bytes()
var n int
var err error
dst := net.IPAddr{
IP: s.raddr.IP,
}
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
} | [
"func",
"(",
"s",
"*",
"sessionUDP",
")",
"WriteResponse",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"// Must give the UDP header to get the source port right.",
"// Reuse the msg buffer, figure out if golang can do gatter-scather IO",
"// with ra... | // WriteResponse writes a response to a request received earlier | [
"WriteResponse",
"writes",
"a",
"response",
"to",
"a",
"request",
"received",
"earlier"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L187-L215 |
162,552 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | parseDstFromOOB | func parseDstFromOOB(oob []byte) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob)
if err != nil {
return nil, fmt.Errorf("parsing socket control message: %s", err)
}
for _, msg := range msgs {
if msg.Header.Level == unix.SOL_IP && msg.Header.Type == unix.IP_ORIGDSTADDR {
pp := &syscall.RawSockaddrInet4{}
// Address family is in native byte order
family := *(*uint16)(unsafe.Pointer(&msg.Data[unsafe.Offsetof(pp.Family)]))
if family != unix.AF_INET {
return nil, fmt.Errorf("original destination is not IPv4.")
}
// Port is in big-endian byte order
if err = binary.Read(bytes.NewReader(msg.Data), binary.BigEndian, pp); err != nil {
return nil, fmt.Errorf("reading original destination address: %s", err)
}
laddr := &net.UDPAddr{
IP: net.IPv4(pp.Addr[0], pp.Addr[1], pp.Addr[2], pp.Addr[3]),
Port: int(pp.Port),
}
return laddr, nil
}
if msg.Header.Level == unix.SOL_IPV6 && msg.Header.Type == unix.IPV6_ORIGDSTADDR {
pp := &syscall.RawSockaddrInet6{}
// Address family is in native byte order
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 data is big-endian (port)
if err = binary.Read(bytes.NewReader(msg.Data), binary.BigEndian, pp); err != nil {
return nil, fmt.Errorf("reading original destination address: %s", err)
}
laddr := &net.UDPAddr{
IP: net.IP(pp.Addr[:]),
Port: int(pp.Port),
Zone: strconv.Itoa(int(scopeId)),
}
return laddr, nil
}
}
return nil, fmt.Errorf("No original destination found!")
} | go | func parseDstFromOOB(oob []byte) (*net.UDPAddr, error) {
msgs, err := syscall.ParseSocketControlMessage(oob)
if err != nil {
return nil, fmt.Errorf("parsing socket control message: %s", err)
}
for _, msg := range msgs {
if msg.Header.Level == unix.SOL_IP && msg.Header.Type == unix.IP_ORIGDSTADDR {
pp := &syscall.RawSockaddrInet4{}
// Address family is in native byte order
family := *(*uint16)(unsafe.Pointer(&msg.Data[unsafe.Offsetof(pp.Family)]))
if family != unix.AF_INET {
return nil, fmt.Errorf("original destination is not IPv4.")
}
// Port is in big-endian byte order
if err = binary.Read(bytes.NewReader(msg.Data), binary.BigEndian, pp); err != nil {
return nil, fmt.Errorf("reading original destination address: %s", err)
}
laddr := &net.UDPAddr{
IP: net.IPv4(pp.Addr[0], pp.Addr[1], pp.Addr[2], pp.Addr[3]),
Port: int(pp.Port),
}
return laddr, nil
}
if msg.Header.Level == unix.SOL_IPV6 && msg.Header.Type == unix.IPV6_ORIGDSTADDR {
pp := &syscall.RawSockaddrInet6{}
// Address family is in native byte order
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 data is big-endian (port)
if err = binary.Read(bytes.NewReader(msg.Data), binary.BigEndian, pp); err != nil {
return nil, fmt.Errorf("reading original destination address: %s", err)
}
laddr := &net.UDPAddr{
IP: net.IP(pp.Addr[:]),
Port: int(pp.Port),
Zone: strconv.Itoa(int(scopeId)),
}
return laddr, nil
}
}
return nil, fmt.Errorf("No original destination found!")
} | [
"func",
"parseDstFromOOB",
"(",
"oob",
"[",
"]",
"byte",
")",
"(",
"*",
"net",
".",
"UDPAddr",
",",
"error",
")",
"{",
"msgs",
",",
"err",
":=",
"syscall",
".",
"ParseSocketControlMessage",
"(",
"oob",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"retur... | // parseDstFromOOB takes oob data and returns the destination IP. | [
"parseDstFromOOB",
"takes",
"oob",
"data",
"and",
"returns",
"the",
"destination",
"IP",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L218-L264 |
162,553 | cilium/cilium | pkg/fqdn/dnsproxy/udp.go | controlMessage | func (s *sessionUDP) controlMessage(src *net.UDPAddr) []byte {
// If the src is definitely an IPv6, then use ipv6's ControlMessage to
// respond otherwise use ipv4's because ipv6's marshal ignores ipv4
// addresses.
if src.IP.To4() == nil {
cm := new(ipv6.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
}
cm := new(ipv4.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
} | go | func (s *sessionUDP) controlMessage(src *net.UDPAddr) []byte {
// If the src is definitely an IPv6, then use ipv6's ControlMessage to
// respond otherwise use ipv4's because ipv6's marshal ignores ipv4
// addresses.
if src.IP.To4() == nil {
cm := new(ipv6.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
}
cm := new(ipv4.ControlMessage)
cm.Src = src.IP
return cm.Marshal()
} | [
"func",
"(",
"s",
"*",
"sessionUDP",
")",
"controlMessage",
"(",
"src",
"*",
"net",
".",
"UDPAddr",
")",
"[",
"]",
"byte",
"{",
"// If the src is definitely an IPv6, then use ipv6's ControlMessage to",
"// respond otherwise use ipv4's because ipv6's marshal ignores ipv4",
"//... | // correctSource returns the oob data with the given source address | [
"correctSource",
"returns",
"the",
"oob",
"data",
"with",
"the",
"given",
"source",
"address"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/dnsproxy/udp.go#L267-L279 |
162,554 | cilium/cilium | pkg/policy/proxyid.go | ParseProxyID | func ParseProxyID(proxyID string) (endpointID uint16, ingress bool, protocol string, port uint16, err error) {
comps := strings.Split(proxyID, ":")
if len(comps) != 4 {
err = fmt.Errorf("invalid proxy ID structure: %s", 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
} | go | func ParseProxyID(proxyID string) (endpointID uint16, ingress bool, protocol string, port uint16, err error) {
comps := strings.Split(proxyID, ":")
if len(comps) != 4 {
err = fmt.Errorf("invalid proxy ID structure: %s", 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
} | [
"func",
"ParseProxyID",
"(",
"proxyID",
"string",
")",
"(",
"endpointID",
"uint16",
",",
"ingress",
"bool",
",",
"protocol",
"string",
",",
"port",
"uint16",
",",
"err",
"error",
")",
"{",
"comps",
":=",
"strings",
".",
"Split",
"(",
"proxyID",
",",
"\""... | // ParseProxyID parses a proxy ID returned by ProxyID and returns its components. | [
"ParseProxyID",
"parses",
"a",
"proxy",
"ID",
"returned",
"by",
"ProxyID",
"and",
"returns",
"its",
"components",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/proxyid.go#L33-L52 |
162,555 | cilium/cilium | pkg/endpoint/status.go | contains | func (ps componentStatus) contains(s *statusLogMsg) bool {
return ps[s.Status.Type] == s
} | go | func (ps componentStatus) contains(s *statusLogMsg) bool {
return ps[s.Status.Type] == s
} | [
"func",
"(",
"ps",
"componentStatus",
")",
"contains",
"(",
"s",
"*",
"statusLogMsg",
")",
"bool",
"{",
"return",
"ps",
"[",
"s",
".",
"Status",
".",
"Type",
"]",
"==",
"s",
"\n",
"}"
] | // contains checks if the given `s` statusLogMsg is present in the
// priorityStatus. | [
"contains",
"checks",
"if",
"the",
"given",
"s",
"statusLogMsg",
"is",
"present",
"in",
"the",
"priorityStatus",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/status.go#L114-L116 |
162,556 | cilium/cilium | pkg/endpoint/status.go | sortByPriority | func (ps componentStatus) sortByPriority() statusLog {
prs := statusTypeSlice{}
for k := range ps {
prs = append(prs, k)
}
sort.Sort(prs)
slogSorted := statusLog{}
for _, pr := range prs {
slogSorted = append(slogSorted, ps[pr])
}
return slogSorted
} | go | func (ps componentStatus) sortByPriority() statusLog {
prs := statusTypeSlice{}
for k := range ps {
prs = append(prs, k)
}
sort.Sort(prs)
slogSorted := statusLog{}
for _, pr := range prs {
slogSorted = append(slogSorted, ps[pr])
}
return slogSorted
} | [
"func",
"(",
"ps",
"componentStatus",
")",
"sortByPriority",
"(",
")",
"statusLog",
"{",
"prs",
":=",
"statusTypeSlice",
"{",
"}",
"\n",
"for",
"k",
":=",
"range",
"ps",
"{",
"prs",
"=",
"append",
"(",
"prs",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
... | // sortByPriority returns a statusLog ordered from highest priority to lowest. | [
"sortByPriority",
"returns",
"a",
"statusLog",
"ordered",
"from",
"highest",
"priority",
"to",
"lowest",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/status.go#L133-L144 |
162,557 | cilium/cilium | pkg/endpoint/status.go | getAndIncIdx | func (e *EndpointStatus) getAndIncIdx() int {
idx := e.Index
e.Index++
if e.Index >= maxLogs {
e.Index = 0
}
// Lets skip the CurrentStatus message from the 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
} | go | func (e *EndpointStatus) getAndIncIdx() int {
idx := e.Index
e.Index++
if e.Index >= maxLogs {
e.Index = 0
}
// Lets skip the CurrentStatus message from the 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
} | [
"func",
"(",
"e",
"*",
"EndpointStatus",
")",
"getAndIncIdx",
"(",
")",
"int",
"{",
"idx",
":=",
"e",
".",
"Index",
"\n",
"e",
".",
"Index",
"++",
"\n",
"if",
"e",
".",
"Index",
">=",
"maxLogs",
"{",
"e",
".",
"Index",
"=",
"0",
"\n",
"}",
"\n"... | // getAndIncIdx returns current free slot index and increments the index to the
// next index that can be overwritten. | [
"getAndIncIdx",
"returns",
"current",
"free",
"slot",
"index",
"and",
"increments",
"the",
"index",
"to",
"the",
"next",
"index",
"that",
"can",
"be",
"overwritten",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/status.go#L176-L193 |
162,558 | cilium/cilium | api/v1/server/restapi/cilium_api.go | Context | func (o *CiliumAPI) Context() *middleware.Context {
if o.context == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | go | func (o *CiliumAPI) Context() *middleware.Context {
if o.context == nil {
o.context = middleware.NewRoutableContext(o.spec, o, nil)
}
return o.context
} | [
"func",
"(",
"o",
"*",
"CiliumAPI",
")",
"Context",
"(",
")",
"*",
"middleware",
".",
"Context",
"{",
"if",
"o",
".",
"context",
"==",
"nil",
"{",
"o",
".",
"context",
"=",
"middleware",
".",
"NewRoutableContext",
"(",
"o",
".",
"spec",
",",
"o",
"... | // Context returns the middleware context for the cilium API | [
"Context",
"returns",
"the",
"middleware",
"context",
"for",
"the",
"cilium",
"API"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/cilium_api.go#L558-L564 |
162,559 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | UnmarshalBinary | func (meta *Meta) UnmarshalBinary(data []byte) error {
return meta.ReadBinary(bytes.NewReader(data))
} | go | func (meta *Meta) UnmarshalBinary(data []byte) error {
return meta.ReadBinary(bytes.NewReader(data))
} | [
"func",
"(",
"meta",
"*",
"Meta",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"meta",
".",
"ReadBinary",
"(",
"bytes",
".",
"NewReader",
"(",
"data",
")",
")",
"\n",
"}"
] | // UnmarshalBinary decodes the metadata from its binary representation. | [
"UnmarshalBinary",
"decodes",
"the",
"metadata",
"from",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L42-L44 |
162,560 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | MarshalBinary | func (meta *Meta) MarshalBinary() ([]byte, error) {
var buf bytes.Buffer
if err := meta.WriteBinary(&buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (meta *Meta) MarshalBinary() ([]byte, error) {
var buf bytes.Buffer
if err := meta.WriteBinary(&buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"meta",
"*",
"Meta",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"meta",
".",
"WriteBinary",
"(",
"&",
"buf",
")",
";",
"err",
"!=",
... | // MarshalBinary encodes the metadata into its binary representation. | [
"MarshalBinary",
"encodes",
"the",
"metadata",
"into",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L47-L53 |
162,561 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | ReadBinary | func (meta *Meta) ReadBinary(r io.Reader) error {
return binary.Read(r, byteorder.Native, meta)
} | go | func (meta *Meta) ReadBinary(r io.Reader) error {
return binary.Read(r, byteorder.Native, meta)
} | [
"func",
"(",
"meta",
"*",
"Meta",
")",
"ReadBinary",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"return",
"binary",
".",
"Read",
"(",
"r",
",",
"byteorder",
".",
"Native",
",",
"meta",
")",
"\n",
"}"
] | // ReadBinary reads the metadata from its binary representation. | [
"ReadBinary",
"reads",
"the",
"metadata",
"from",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L56-L58 |
162,562 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | WriteBinary | func (meta *Meta) WriteBinary(w io.Writer) error {
return binary.Write(w, byteorder.Native, meta)
} | go | func (meta *Meta) WriteBinary(w io.Writer) error {
return binary.Write(w, byteorder.Native, meta)
} | [
"func",
"(",
"meta",
"*",
"Meta",
")",
"WriteBinary",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"return",
"binary",
".",
"Write",
"(",
"w",
",",
"byteorder",
".",
"Native",
",",
"meta",
")",
"\n",
"}"
] | // WriteBinary writes the metadata into its binary representation. | [
"WriteBinary",
"writes",
"the",
"metadata",
"into",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L61-L63 |
162,563 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | Decode | func (pl *Payload) Decode(data []byte) error {
// Note that this method can't be named UnmarshalBinary, because the gob encoder would call
// this method, resulting in infinite recursion.
return pl.ReadBinary(bytes.NewBuffer(data))
} | go | func (pl *Payload) Decode(data []byte) error {
// Note that this method can't be named UnmarshalBinary, because the gob encoder would call
// this method, resulting in infinite recursion.
return pl.ReadBinary(bytes.NewBuffer(data))
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"Decode",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"// Note that this method can't be named UnmarshalBinary, because the gob encoder would call",
"// this method, resulting in infinite recursion.",
"return",
"pl",
".",
"ReadBin... | // Decode decodes the payload from its binary representation. | [
"Decode",
"decodes",
"the",
"payload",
"from",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L74-L78 |
162,564 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | Encode | func (pl *Payload) Encode() ([]byte, error) {
// Note that this method can't be named MarshalBinary, because the gob encoder would 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
} | go | func (pl *Payload) Encode() ([]byte, error) {
// Note that this method can't be named MarshalBinary, because the gob encoder would 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
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"Encode",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Note that this method can't be named MarshalBinary, because the gob encoder would call",
"// this method, resulting in infinite recursion.",
"var",
"buf",
"bytes",... | // Encode encodes the payload into its binary representation. | [
"Encode",
"encodes",
"the",
"payload",
"into",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L81-L89 |
162,565 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | ReadBinary | func (pl *Payload) ReadBinary(r io.Reader) error {
dec := gob.NewDecoder(r)
return pl.DecodeBinary(dec)
} | go | func (pl *Payload) ReadBinary(r io.Reader) error {
dec := gob.NewDecoder(r)
return pl.DecodeBinary(dec)
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"ReadBinary",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"dec",
":=",
"gob",
".",
"NewDecoder",
"(",
"r",
")",
"\n",
"return",
"pl",
".",
"DecodeBinary",
"(",
"dec",
")",
"\n",
"}"
] | // ReadBinary reads the payload from its binary representation. | [
"ReadBinary",
"reads",
"the",
"payload",
"from",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L92-L95 |
162,566 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | WriteBinary | func (pl *Payload) WriteBinary(w io.Writer) error {
enc := gob.NewEncoder(w)
return pl.EncodeBinary(enc)
} | go | func (pl *Payload) WriteBinary(w io.Writer) error {
enc := gob.NewEncoder(w)
return pl.EncodeBinary(enc)
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"WriteBinary",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"enc",
":=",
"gob",
".",
"NewEncoder",
"(",
"w",
")",
"\n",
"return",
"pl",
".",
"EncodeBinary",
"(",
"enc",
")",
"\n",
"}"
] | // WriteBinary writes the payload into its binary representation. | [
"WriteBinary",
"writes",
"the",
"payload",
"into",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L98-L101 |
162,567 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | EncodeBinary | func (pl *Payload) EncodeBinary(enc *gob.Encoder) error {
return enc.Encode(pl)
} | go | func (pl *Payload) EncodeBinary(enc *gob.Encoder) error {
return enc.Encode(pl)
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"EncodeBinary",
"(",
"enc",
"*",
"gob",
".",
"Encoder",
")",
"error",
"{",
"return",
"enc",
".",
"Encode",
"(",
"pl",
")",
"\n",
"}"
] | // EncodeBinary writes the payload into its binary representation. | [
"EncodeBinary",
"writes",
"the",
"payload",
"into",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L104-L106 |
162,568 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | DecodeBinary | func (pl *Payload) DecodeBinary(dec *gob.Decoder) error {
return dec.Decode(pl)
} | go | func (pl *Payload) DecodeBinary(dec *gob.Decoder) error {
return dec.Decode(pl)
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"DecodeBinary",
"(",
"dec",
"*",
"gob",
".",
"Decoder",
")",
"error",
"{",
"return",
"dec",
".",
"Decode",
"(",
"pl",
")",
"\n",
"}"
] | // DecodeBinary reads the payload from its binary representation. | [
"DecodeBinary",
"reads",
"the",
"payload",
"from",
"its",
"binary",
"representation",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L109-L111 |
162,569 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | ReadMetaPayload | func ReadMetaPayload(r io.Reader, meta *Meta, pl *Payload) error {
if err := meta.ReadBinary(r); err != nil {
return err
}
// 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)))
} | go | func ReadMetaPayload(r io.Reader, meta *Meta, pl *Payload) error {
if err := meta.ReadBinary(r); err != nil {
return err
}
// 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)))
} | [
"func",
"ReadMetaPayload",
"(",
"r",
"io",
".",
"Reader",
",",
"meta",
"*",
"Meta",
",",
"pl",
"*",
"Payload",
")",
"error",
"{",
"if",
"err",
":=",
"meta",
".",
"ReadBinary",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}... | // ReadMetaPayload reads a Meta and Payload from a Cilium monitor connection. | [
"ReadMetaPayload",
"reads",
"a",
"Meta",
"and",
"Payload",
"from",
"a",
"Cilium",
"monitor",
"connection",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L114-L121 |
162,570 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | WriteMetaPayload | func WriteMetaPayload(w io.Writer, meta *Meta, pl *Payload) error {
payloadBuf, err := pl.Encode()
if err != nil {
return err
}
meta.Size = uint32(len(payloadBuf))
meta.WriteBinary(w)
_, err = w.Write(payloadBuf)
return err
} | go | func WriteMetaPayload(w io.Writer, meta *Meta, pl *Payload) error {
payloadBuf, err := pl.Encode()
if err != nil {
return err
}
meta.Size = uint32(len(payloadBuf))
meta.WriteBinary(w)
_, err = w.Write(payloadBuf)
return err
} | [
"func",
"WriteMetaPayload",
"(",
"w",
"io",
".",
"Writer",
",",
"meta",
"*",
"Meta",
",",
"pl",
"*",
"Payload",
")",
"error",
"{",
"payloadBuf",
",",
"err",
":=",
"pl",
".",
"Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
... | // WriteMetaPayload writes a Meta and Payload into a Cilium monitor connection.
// meta.Size is set to the size of the encoded Payload. | [
"WriteMetaPayload",
"writes",
"a",
"Meta",
"and",
"Payload",
"into",
"a",
"Cilium",
"monitor",
"connection",
".",
"meta",
".",
"Size",
"is",
"set",
"to",
"the",
"size",
"of",
"the",
"encoded",
"Payload",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L125-L134 |
162,571 | cilium/cilium | pkg/monitor/payload/monitor_payload.go | BuildMessage | func (pl *Payload) BuildMessage() ([]byte, error) {
plBuf, err := pl.Encode()
if err != nil {
return nil, fmt.Errorf("unable to encode payload: %s", err)
}
meta := &Meta{Size: uint32(len(plBuf))}
metaBuf, err := meta.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("unable to encode metadata: %s", err)
}
return append(metaBuf, plBuf...), nil
} | go | func (pl *Payload) BuildMessage() ([]byte, error) {
plBuf, err := pl.Encode()
if err != nil {
return nil, fmt.Errorf("unable to encode payload: %s", err)
}
meta := &Meta{Size: uint32(len(plBuf))}
metaBuf, err := meta.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("unable to encode metadata: %s", err)
}
return append(metaBuf, plBuf...), nil
} | [
"func",
"(",
"pl",
"*",
"Payload",
")",
"BuildMessage",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"plBuf",
",",
"err",
":=",
"pl",
".",
"Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
... | // BuildMessage builds the binary message to be sent and returns it | [
"BuildMessage",
"builds",
"the",
"binary",
"message",
"to",
"be",
"sent",
"and",
"returns",
"it"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/payload/monitor_payload.go#L137-L150 |
162,572 | cilium/cilium | pkg/endpoint/connector/add.go | Endpoint2IfName | func Endpoint2IfName(endpointID string) string {
sum := fmt.Sprintf("%x", sha256.Sum256([]byte(endpointID)))
// returned string length should be < unix.IFNAMSIZ
truncateLength := uint(unix.IFNAMSIZ - len(temporaryInterfacePrefix) - 1)
return hostInterfacePrefix + truncateString(sum, truncateLength)
} | go | func Endpoint2IfName(endpointID string) string {
sum := fmt.Sprintf("%x", sha256.Sum256([]byte(endpointID)))
// returned string length should be < unix.IFNAMSIZ
truncateLength := uint(unix.IFNAMSIZ - len(temporaryInterfacePrefix) - 1)
return hostInterfacePrefix + truncateString(sum, truncateLength)
} | [
"func",
"Endpoint2IfName",
"(",
"endpointID",
"string",
")",
"string",
"{",
"sum",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sha256",
".",
"Sum256",
"(",
"[",
"]",
"byte",
"(",
"endpointID",
")",
")",
")",
"\n",
"// returned string length should ... | // Endpoint2IfName returns the host interface name for the given endpointID. | [
"Endpoint2IfName",
"returns",
"the",
"host",
"interface",
"name",
"for",
"the",
"given",
"endpointID",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/connector/add.go#L43-L48 |
162,573 | cilium/cilium | pkg/endpoint/connector/add.go | WriteSysConfig | func WriteSysConfig(fileName, value string) error {
f, err := os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return fmt.Errorf("unable to open configuration file: %s", err)
}
_, err = f.WriteString(value)
if err != nil {
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
} | go | func WriteSysConfig(fileName, value string) error {
f, err := os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return fmt.Errorf("unable to open configuration file: %s", err)
}
_, err = f.WriteString(value)
if err != nil {
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
} | [
"func",
"WriteSysConfig",
"(",
"fileName",
",",
"value",
"string",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"fileName",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
",",
"0666",
")",
... | // WriteSysConfig tries to emulate a sysctl call by writing directly to the
// given fileName the given value. | [
"WriteSysConfig",
"tries",
"to",
"emulate",
"a",
"sysctl",
"call",
"by",
"writing",
"directly",
"to",
"the",
"given",
"fileName",
"the",
"given",
"value",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/connector/add.go#L82-L97 |
162,574 | cilium/cilium | pkg/endpoint/connector/add.go | GetNetInfoFromPID | func GetNetInfoFromPID(pid int) (int, string, net.IP, error) {
netNs, err := ns.GetNS(fmt.Sprintf("/proc/%d/ns/net", pid))
if err != nil {
return 0, "", nil, err
}
defer netNs.Close()
var (
lxcMAC string
parentIndex int
ip net.IP
)
err = netNs.Do(func(_ ns.NetNS) error {
links, err := netlink.LinkList()
if err != 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().ParentIndex
log.Debugf("link found: %+v", l.Attrs())
return nil
}
}
}
return nil
})
return parentIndex, lxcMAC, ip, err
} | go | func GetNetInfoFromPID(pid int) (int, string, net.IP, error) {
netNs, err := ns.GetNS(fmt.Sprintf("/proc/%d/ns/net", pid))
if err != nil {
return 0, "", nil, err
}
defer netNs.Close()
var (
lxcMAC string
parentIndex int
ip net.IP
)
err = netNs.Do(func(_ ns.NetNS) error {
links, err := netlink.LinkList()
if err != 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().ParentIndex
log.Debugf("link found: %+v", l.Attrs())
return nil
}
}
}
return nil
})
return parentIndex, lxcMAC, ip, err
} | [
"func",
"GetNetInfoFromPID",
"(",
"pid",
"int",
")",
"(",
"int",
",",
"string",
",",
"net",
".",
"IP",
",",
"error",
")",
"{",
"netNs",
",",
"err",
":=",
"ns",
".",
"GetNS",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pid",
")",
")",
"\n... | // GetNetInfoFromPID returns the index of the interface parent, the MAC address
// and IP address of the first interface that contains an IP address with global
// scope. | [
"GetNetInfoFromPID",
"returns",
"the",
"index",
"of",
"the",
"interface",
"parent",
"the",
"MAC",
"address",
"and",
"IP",
"address",
"of",
"the",
"first",
"interface",
"that",
"contains",
"an",
"IP",
"address",
"with",
"global",
"scope",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/connector/add.go#L102-L138 |
162,575 | cilium/cilium | api/v1/models/debug_info.go | Validate | func (m *DebugInfo) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCiliumStatus(formats); err != nil {
res = append(res, err)
}
if err := m.validateEndpointList(formats); err != 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
} | go | func (m *DebugInfo) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCiliumStatus(formats); err != nil {
res = append(res, err)
}
if err := m.validateEndpointList(formats); err != 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
} | [
"func",
"(",
"m",
"*",
"DebugInfo",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCiliumStatus",
"(",
"formats",
")",
";",
"err",
"!=",
"n... | // Validate validates this debug info | [
"Validate",
"validates",
"this",
"debug",
"info"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/debug_info.go#L53-L76 |
162,576 | cilium/cilium | pkg/kvstore/allocator/localkeys.go | allocate | func (lk *localKeys) allocate(key string, val idpool.ID) (idpool.ID, error) {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
if val != k.val {
return idpool.NoID, fmt.Errorf("local key already allocated with different value (%s != %s)", val, 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, fieldID: val, fieldRefCnt: 1})
return val, nil
} | go | func (lk *localKeys) allocate(key string, val idpool.ID) (idpool.ID, error) {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
if val != k.val {
return idpool.NoID, fmt.Errorf("local key already allocated with different value (%s != %s)", val, 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, fieldID: val, fieldRefCnt: 1})
return val, nil
} | [
"func",
"(",
"lk",
"*",
"localKeys",
")",
"allocate",
"(",
"key",
"string",
",",
"val",
"idpool",
".",
"ID",
")",
"(",
"idpool",
".",
"ID",
",",
"error",
")",
"{",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lk",
".",
"Unlock",
"(",
")",
"\n\n... | // allocate creates an entry for key in localKeys if needed and increments the
// refcnt. The value associated with the key must match the local cache or an
// error is returned | [
"allocate",
"creates",
"an",
"entry",
"for",
"key",
"in",
"localKeys",
"if",
"needed",
"and",
"increments",
"the",
"refcnt",
".",
"The",
"value",
"associated",
"with",
"the",
"key",
"must",
"match",
"the",
"local",
"cache",
"or",
"an",
"error",
"is",
"retu... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/kvstore/allocator/localkeys.go#L54-L73 |
162,577 | cilium/cilium | pkg/kvstore/allocator/localkeys.go | lookupID | func (lk *localKeys) lookupID(id idpool.ID) string {
lk.RLock()
defer lk.RUnlock()
if k, ok := lk.ids[id]; ok {
return k.key
}
return ""
} | go | func (lk *localKeys) lookupID(id idpool.ID) string {
lk.RLock()
defer lk.RUnlock()
if k, ok := lk.ids[id]; ok {
return k.key
}
return ""
} | [
"func",
"(",
"lk",
"*",
"localKeys",
")",
"lookupID",
"(",
"id",
"idpool",
".",
"ID",
")",
"string",
"{",
"lk",
".",
"RLock",
"(",
")",
"\n",
"defer",
"lk",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"k",
",",
"ok",
":=",
"lk",
".",
"ids",
"[",
... | // lookupID returns the key for a given ID or an empty string | [
"lookupID",
"returns",
"the",
"key",
"for",
"a",
"given",
"ID",
"or",
"an",
"empty",
"string"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/kvstore/allocator/localkeys.go#L89-L98 |
162,578 | cilium/cilium | pkg/kvstore/allocator/localkeys.go | use | func (lk *localKeys) use(key string) idpool.ID {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
// unverified keys behave as if they do not exist
if !k.verified {
return idpool.NoID
}
k.refcnt++
kvstore.Trace("Incremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: k.val, fieldRefCnt: k.refcnt})
return k.val
}
return idpool.NoID
} | go | func (lk *localKeys) use(key string) idpool.ID {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
// unverified keys behave as if they do not exist
if !k.verified {
return idpool.NoID
}
k.refcnt++
kvstore.Trace("Incremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: k.val, fieldRefCnt: k.refcnt})
return k.val
}
return idpool.NoID
} | [
"func",
"(",
"lk",
"*",
"localKeys",
")",
"use",
"(",
"key",
"string",
")",
"idpool",
".",
"ID",
"{",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lk",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"k",
",",
"ok",
":=",
"lk",
".",
"keys",
"[",
"key"... | // use increments the refcnt of the key and returns its value | [
"use",
"increments",
"the",
"refcnt",
"of",
"the",
"key",
"and",
"returns",
"its",
"value"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/kvstore/allocator/localkeys.go#L101-L117 |
162,579 | cilium/cilium | pkg/kvstore/allocator/localkeys.go | release | func (lk *localKeys) release(key string) (lastUse bool, err error) {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
k.refcnt--
kvstore.Trace("Decremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: k.val, fieldRefCnt: k.refcnt})
if k.refcnt == 0 {
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")
} | go | func (lk *localKeys) release(key string) (lastUse bool, err error) {
lk.Lock()
defer lk.Unlock()
if k, ok := lk.keys[key]; ok {
k.refcnt--
kvstore.Trace("Decremented local key refcnt", nil, logrus.Fields{fieldKey: key, fieldID: k.val, fieldRefCnt: k.refcnt})
if k.refcnt == 0 {
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")
} | [
"func",
"(",
"lk",
"*",
"localKeys",
")",
"release",
"(",
"key",
"string",
")",
"(",
"lastUse",
"bool",
",",
"err",
"error",
")",
"{",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"if",
"k",
",",
"ok",
":=",
... | // release releases the refcnt of a key. When the last reference was released,
// the key is deleted and the returned lastUse value is true. | [
"release",
"releases",
"the",
"refcnt",
"of",
"a",
"key",
".",
"When",
"the",
"last",
"reference",
"was",
"released",
"the",
"key",
"is",
"deleted",
"and",
"the",
"returned",
"lastUse",
"value",
"is",
"true",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/kvstore/allocator/localkeys.go#L121-L137 |
162,580 | cilium/cilium | pkg/crypto/sha1/sha1.go | Copy | func (d *digest) Copy() (ResumableHash, error) {
newHash := hash.Hash(sha1.New())
state, err := d.Hash.(encoding.BinaryMarshaler).MarshalBinary()
if err != nil {
return nil, err
}
if err := newHash.(encoding.BinaryUnmarshaler).UnmarshalBinary(state); err != nil {
return nil, err
}
return &digest{
newHash,
}, nil
} | go | func (d *digest) Copy() (ResumableHash, error) {
newHash := hash.Hash(sha1.New())
state, err := d.Hash.(encoding.BinaryMarshaler).MarshalBinary()
if err != nil {
return nil, err
}
if err := newHash.(encoding.BinaryUnmarshaler).UnmarshalBinary(state); err != nil {
return nil, err
}
return &digest{
newHash,
}, nil
} | [
"func",
"(",
"d",
"*",
"digest",
")",
"Copy",
"(",
")",
"(",
"ResumableHash",
",",
"error",
")",
"{",
"newHash",
":=",
"hash",
".",
"Hash",
"(",
"sha1",
".",
"New",
"(",
")",
")",
"\n",
"state",
",",
"err",
":=",
"d",
".",
"Hash",
".",
"(",
"... | // Copy duplicates the hash and returns the copy. | [
"Copy",
"duplicates",
"the",
"hash",
"and",
"returns",
"the",
"copy",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/crypto/sha1/sha1.go#L53-L65 |
162,581 | cilium/cilium | api/v1/server/restapi/ipam/post_ip_a_m_responses.go | WithPayload | func (o *PostIPAMCreated) WithPayload(payload *models.IPAMResponse) *PostIPAMCreated {
o.Payload = payload
return o
} | go | func (o *PostIPAMCreated) WithPayload(payload *models.IPAMResponse) *PostIPAMCreated {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PostIPAMCreated",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"IPAMResponse",
")",
"*",
"PostIPAMCreated",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the post Ip a m created response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"post",
"Ip",
"a",
"m",
"created",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/ipam/post_ip_a_m_responses.go#L38-L41 |
162,582 | cilium/cilium | api/v1/server/restapi/ipam/post_ip_a_m_responses.go | WithPayload | func (o *PostIPAMFailure) WithPayload(payload models.Error) *PostIPAMFailure {
o.Payload = payload
return o
} | go | func (o *PostIPAMFailure) WithPayload(payload models.Error) *PostIPAMFailure {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PostIPAMFailure",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"PostIPAMFailure",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the post Ip a m failure response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"post",
"Ip",
"a",
"m",
"failure",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/ipam/post_ip_a_m_responses.go#L82-L85 |
162,583 | cilium/cilium | pkg/client/prefilter.go | GetPrefilter | func (c *Client) GetPrefilter() (*models.Prefilter, error) {
resp, err := c.Prefilter.GetPrefilter(nil)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) GetPrefilter() (*models.Prefilter, error) {
resp, err := c.Prefilter.GetPrefilter(nil)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetPrefilter",
"(",
")",
"(",
"*",
"models",
".",
"Prefilter",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"c",
".",
"Prefilter",
".",
"GetPrefilter",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"... | // GetPrefilter returns a list of all CIDR prefixes | [
"GetPrefilter",
"returns",
"a",
"list",
"of",
"all",
"CIDR",
"prefixes"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/prefilter.go#L24-L30 |
162,584 | cilium/cilium | pkg/client/prefilter.go | PatchPrefilter | func (c *Client) PatchPrefilter(spec *models.PrefilterSpec) (*models.Prefilter, error) {
params := prefilter.NewPatchPrefilterParams().WithPrefilterSpec(spec).WithTimeout(api.ClientTimeout)
resp, err := c.Prefilter.PatchPrefilter(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) PatchPrefilter(spec *models.PrefilterSpec) (*models.Prefilter, error) {
params := prefilter.NewPatchPrefilterParams().WithPrefilterSpec(spec).WithTimeout(api.ClientTimeout)
resp, err := c.Prefilter.PatchPrefilter(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PatchPrefilter",
"(",
"spec",
"*",
"models",
".",
"PrefilterSpec",
")",
"(",
"*",
"models",
".",
"Prefilter",
",",
"error",
")",
"{",
"params",
":=",
"prefilter",
".",
"NewPatchPrefilterParams",
"(",
")",
".",
"With... | // PatchPrefilter sets a list of CIDR prefixes | [
"PatchPrefilter",
"sets",
"a",
"list",
"of",
"CIDR",
"prefixes"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/prefilter.go#L33-L40 |
162,585 | cilium/cilium | pkg/client/prefilter.go | DeletePrefilter | func (c *Client) DeletePrefilter(spec *models.PrefilterSpec) error {
current, err := c.GetPrefilter()
if err != nil {
return Hint(err)
}
deleteSet := map[string]bool{}
keepList := []string{}
for _, delCIDR := range spec.Deny {
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(update)
return Hint(err)
} | go | func (c *Client) DeletePrefilter(spec *models.PrefilterSpec) error {
current, err := c.GetPrefilter()
if err != nil {
return Hint(err)
}
deleteSet := map[string]bool{}
keepList := []string{}
for _, delCIDR := range spec.Deny {
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(update)
return Hint(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeletePrefilter",
"(",
"spec",
"*",
"models",
".",
"PrefilterSpec",
")",
"error",
"{",
"current",
",",
"err",
":=",
"c",
".",
"GetPrefilter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Hint",
"(",... | // DeletePrefilter deletes a list of CIDR prefixes | [
"DeletePrefilter",
"deletes",
"a",
"list",
"of",
"CIDR",
"prefixes"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/prefilter.go#L43-L67 |
162,586 | cilium/cilium | api/v1/client/daemon/get_config_parameters.go | WithTimeout | func (o *GetConfigParams) WithTimeout(timeout time.Duration) *GetConfigParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetConfigParams) WithTimeout(timeout time.Duration) *GetConfigParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetConfigParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetConfigParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get config params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/daemon/get_config_parameters.go#L69-L72 |
162,587 | cilium/cilium | api/v1/client/daemon/get_config_parameters.go | WithContext | func (o *GetConfigParams) WithContext(ctx context.Context) *GetConfigParams {
o.SetContext(ctx)
return o
} | go | func (o *GetConfigParams) WithContext(ctx context.Context) *GetConfigParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetConfigParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetConfigParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get config params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/daemon/get_config_parameters.go#L80-L83 |
162,588 | cilium/cilium | api/v1/client/daemon/get_config_parameters.go | WithHTTPClient | func (o *GetConfigParams) WithHTTPClient(client *http.Client) *GetConfigParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetConfigParams) WithHTTPClient(client *http.Client) *GetConfigParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetConfigParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetConfigParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get config params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/daemon/get_config_parameters.go#L91-L94 |
162,589 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_id_responses.go | WithPayload | func (o *GetFqdnCacheIDOK) WithPayload(payload []*models.DNSLookup) *GetFqdnCacheIDOK {
o.Payload = payload
return o
} | go | func (o *GetFqdnCacheIDOK) WithPayload(payload []*models.DNSLookup) *GetFqdnCacheIDOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheIDOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"DNSLookup",
")",
"*",
"GetFqdnCacheIDOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get fqdn cache Id o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"fqdn",
"cache",
"Id",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_id_responses.go#L38-L41 |
162,590 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_id_responses.go | WithPayload | func (o *GetFqdnCacheIDBadRequest) WithPayload(payload models.Error) *GetFqdnCacheIDBadRequest {
o.Payload = payload
return o
} | go | func (o *GetFqdnCacheIDBadRequest) WithPayload(payload models.Error) *GetFqdnCacheIDBadRequest {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheIDBadRequest",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"GetFqdnCacheIDBadRequest",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get fqdn cache Id bad request response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"fqdn",
"cache",
"Id",
"bad",
"request",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_id_responses.go#L85-L88 |
162,591 | cilium/cilium | pkg/fqdn/matchpattern/matchpattern.go | Validate | func Validate(pattern string) (matcher *regexp.Regexp, err error) {
pattern = strings.TrimSpace(pattern)
pattern = strings.ToLower(pattern)
// error check
if strings.ContainsAny(pattern, "[]+{},") {
return nil, errors.New(`Only alphanumeric ASCII characters, the hyphen "-", "." and "*" are allowed in a matchPattern`)
}
return regexp.Compile(ToRegexp(pattern))
} | go | func Validate(pattern string) (matcher *regexp.Regexp, err error) {
pattern = strings.TrimSpace(pattern)
pattern = strings.ToLower(pattern)
// error check
if strings.ContainsAny(pattern, "[]+{},") {
return nil, errors.New(`Only alphanumeric ASCII characters, the hyphen "-", "." and "*" are allowed in a matchPattern`)
}
return regexp.Compile(ToRegexp(pattern))
} | [
"func",
"Validate",
"(",
"pattern",
"string",
")",
"(",
"matcher",
"*",
"regexp",
".",
"Regexp",
",",
"err",
"error",
")",
"{",
"pattern",
"=",
"strings",
".",
"TrimSpace",
"(",
"pattern",
")",
"\n",
"pattern",
"=",
"strings",
".",
"ToLower",
"(",
"pat... | // Validate ensures that pattern is a parseable matchPattern. It returns the
// regexp generated when validating. | [
"Validate",
"ensures",
"that",
"pattern",
"is",
"a",
"parseable",
"matchPattern",
".",
"It",
"returns",
"the",
"regexp",
"generated",
"when",
"validating",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/matchpattern/matchpattern.go#L29-L39 |
162,592 | cilium/cilium | pkg/fqdn/matchpattern/matchpattern.go | Sanitize | func Sanitize(pattern string) string {
if pattern == "*" {
return pattern
}
return strings.ToLower(dns.Fqdn(pattern))
} | go | func Sanitize(pattern string) string {
if pattern == "*" {
return pattern
}
return strings.ToLower(dns.Fqdn(pattern))
} | [
"func",
"Sanitize",
"(",
"pattern",
"string",
")",
"string",
"{",
"if",
"pattern",
"==",
"\"",
"\"",
"{",
"return",
"pattern",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"ToLower",
"(",
"dns",
".",
"Fqdn",
"(",
"pattern",
")",
")",
"\n",
"}"
] | // Sanitize canonicalized the pattern for use by ToRegexp | [
"Sanitize",
"canonicalized",
"the",
"pattern",
"for",
"use",
"by",
"ToRegexp"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/matchpattern/matchpattern.go#L42-L48 |
162,593 | cilium/cilium | pkg/cidr/cidr.go | NewCIDR | func NewCIDR(ipnet *net.IPNet) *CIDR {
if ipnet == nil {
return nil
}
return &CIDR{ipnet}
} | go | func NewCIDR(ipnet *net.IPNet) *CIDR {
if ipnet == nil {
return nil
}
return &CIDR{ipnet}
} | [
"func",
"NewCIDR",
"(",
"ipnet",
"*",
"net",
".",
"IPNet",
")",
"*",
"CIDR",
"{",
"if",
"ipnet",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"&",
"CIDR",
"{",
"ipnet",
"}",
"\n",
"}"
] | // NewCIDR returns a new CIDR using a net.IPNet | [
"NewCIDR",
"returns",
"a",
"new",
"CIDR",
"using",
"a",
"net",
".",
"IPNet"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/cidr/cidr.go#L23-L29 |
162,594 | cilium/cilium | pkg/cidr/cidr.go | DeepCopy | func (n *CIDR) DeepCopy() *CIDR {
if n == nil {
return nil
}
out := &CIDR{
&net.IPNet{
IP: make([]byte, len(n.IP)),
Mask: make([]byte, len(n.Mask)),
},
}
copy(out.IP, n.IP)
copy(out.Mask, n.Mask)
return out
} | go | func (n *CIDR) DeepCopy() *CIDR {
if n == nil {
return nil
}
out := &CIDR{
&net.IPNet{
IP: make([]byte, len(n.IP)),
Mask: make([]byte, len(n.Mask)),
},
}
copy(out.IP, n.IP)
copy(out.Mask, n.Mask)
return out
} | [
"func",
"(",
"n",
"*",
"CIDR",
")",
"DeepCopy",
"(",
")",
"*",
"CIDR",
"{",
"if",
"n",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"&",
"CIDR",
"{",
"&",
"net",
".",
"IPNet",
"{",
"IP",
":",
"make",
"(",
"[",
"]",
"byte... | // DeepCopy creates a deep copy of a CIDR | [
"DeepCopy",
"creates",
"a",
"deep",
"copy",
"of",
"a",
"CIDR"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/cidr/cidr.go#L37-L50 |
162,595 | cilium/cilium | pkg/cidr/cidr.go | ParseCIDR | func ParseCIDR(str string) (*CIDR, error) {
_, ipnet, err := net.ParseCIDR(str)
if err != nil {
return nil, err
}
return NewCIDR(ipnet), nil
} | go | func ParseCIDR(str string) (*CIDR, error) {
_, ipnet, err := net.ParseCIDR(str)
if err != nil {
return nil, err
}
return NewCIDR(ipnet), nil
} | [
"func",
"ParseCIDR",
"(",
"str",
"string",
")",
"(",
"*",
"CIDR",
",",
"error",
")",
"{",
"_",
",",
"ipnet",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}"... | // ParseCIDR parses the CIDR string using net.ParseCIDR | [
"ParseCIDR",
"parses",
"the",
"CIDR",
"string",
"using",
"net",
".",
"ParseCIDR"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/cidr/cidr.go#L53-L59 |
162,596 | cilium/cilium | pkg/cidr/cidr.go | MustParseCIDR | func MustParseCIDR(str string) *CIDR {
c, err := ParseCIDR(str)
if err != nil {
panic(fmt.Sprintf("Unable to parse CIDR '%s': %s", str, err))
}
return c
} | go | func MustParseCIDR(str string) *CIDR {
c, err := ParseCIDR(str)
if err != nil {
panic(fmt.Sprintf("Unable to parse CIDR '%s': %s", str, err))
}
return c
} | [
"func",
"MustParseCIDR",
"(",
"str",
"string",
")",
"*",
"CIDR",
"{",
"c",
",",
"err",
":=",
"ParseCIDR",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"str",
",",
"err",
")",
"... | // MustParseCIDR parses the CIDR string using net.ParseCIDR and panics if the
// CIDR cannot be parsed | [
"MustParseCIDR",
"parses",
"the",
"CIDR",
"string",
"using",
"net",
".",
"ParseCIDR",
"and",
"panics",
"if",
"the",
"CIDR",
"cannot",
"be",
"parsed"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/cidr/cidr.go#L63-L69 |
162,597 | cilium/cilium | api/v1/client/prefilter/get_prefilter_parameters.go | WithTimeout | func (o *GetPrefilterParams) WithTimeout(timeout time.Duration) *GetPrefilterParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetPrefilterParams) WithTimeout(timeout time.Duration) *GetPrefilterParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetPrefilterParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetPrefilterParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get prefilter params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"prefilter",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/prefilter/get_prefilter_parameters.go#L69-L72 |
162,598 | cilium/cilium | api/v1/client/prefilter/get_prefilter_parameters.go | WithContext | func (o *GetPrefilterParams) WithContext(ctx context.Context) *GetPrefilterParams {
o.SetContext(ctx)
return o
} | go | func (o *GetPrefilterParams) WithContext(ctx context.Context) *GetPrefilterParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetPrefilterParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetPrefilterParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get prefilter params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"prefilter",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/prefilter/get_prefilter_parameters.go#L80-L83 |
162,599 | cilium/cilium | api/v1/client/prefilter/get_prefilter_parameters.go | WithHTTPClient | func (o *GetPrefilterParams) WithHTTPClient(client *http.Client) *GetPrefilterParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetPrefilterParams) WithHTTPClient(client *http.Client) *GetPrefilterParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetPrefilterParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetPrefilterParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get prefilter params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"prefilter",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/prefilter/get_prefilter_parameters.go#L91-L94 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.