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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
163,400 | cilium/cilium | api/v1/client/policy/delete_policy_parameters.go | WithLabels | func (o *DeletePolicyParams) WithLabels(labels models.Labels) *DeletePolicyParams {
o.SetLabels(labels)
return o
} | go | func (o *DeletePolicyParams) WithLabels(labels models.Labels) *DeletePolicyParams {
o.SetLabels(labels)
return o
} | [
"func",
"(",
"o",
"*",
"DeletePolicyParams",
")",
"WithLabels",
"(",
"labels",
"models",
".",
"Labels",
")",
"*",
"DeletePolicyParams",
"{",
"o",
".",
"SetLabels",
"(",
"labels",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithLabels adds the labels to the delete policy params | [
"WithLabels",
"adds",
"the",
"labels",
"to",
"the",
"delete",
"policy",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/policy/delete_policy_parameters.go#L108-L111 |
163,401 | cilium/cilium | api/v1/server/restapi/endpoint/patch_endpoint_id_config.go | NewPatchEndpointIDConfig | func NewPatchEndpointIDConfig(ctx *middleware.Context, handler PatchEndpointIDConfigHandler) *PatchEndpointIDConfig {
return &PatchEndpointIDConfig{Context: ctx, Handler: handler}
} | go | func NewPatchEndpointIDConfig(ctx *middleware.Context, handler PatchEndpointIDConfigHandler) *PatchEndpointIDConfig {
return &PatchEndpointIDConfig{Context: ctx, Handler: handler}
} | [
"func",
"NewPatchEndpointIDConfig",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"PatchEndpointIDConfigHandler",
")",
"*",
"PatchEndpointIDConfig",
"{",
"return",
"&",
"PatchEndpointIDConfig",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewPatchEndpointIDConfig creates a new http.Handler for the patch endpoint ID config operation | [
"NewPatchEndpointIDConfig",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"patch",
"endpoint",
"ID",
"config",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/patch_endpoint_id_config.go#L28-L30 |
163,402 | cilium/cilium | pkg/metrics/metrics.go | RegisterList | func RegisterList(list []prometheus.Collector) error {
registered := []prometheus.Collector{}
for _, c := range list {
if err := Register(c); err != nil {
for _, c := range registered {
Unregister(c)
}
return err
}
registered = append(registered, c)
}
return nil
} | go | func RegisterList(list []prometheus.Collector) error {
registered := []prometheus.Collector{}
for _, c := range list {
if err := Register(c); err != nil {
for _, c := range registered {
Unregister(c)
}
return err
}
registered = append(registered, c)
}
return nil
} | [
"func",
"RegisterList",
"(",
"list",
"[",
"]",
"prometheus",
".",
"Collector",
")",
"error",
"{",
"registered",
":=",
"[",
"]",
"prometheus",
".",
"Collector",
"{",
"}",
"\n\n",
"for",
"_",
",",
"c",
":=",
"range",
"list",
"{",
"if",
"err",
":=",
"Register",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"registered",
"{",
"Unregister",
"(",
"c",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"registered",
"=",
"append",
"(",
"registered",
",",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // RegisterList registers a list of collectors. If registration of one
// collector fails, no collector is registered. | [
"RegisterList",
"registers",
"a",
"list",
"of",
"collectors",
".",
"If",
"registration",
"of",
"one",
"collector",
"fails",
"no",
"collector",
"is",
"registered",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/metrics/metrics.go#L641-L656 |
163,403 | cilium/cilium | pkg/metrics/metrics.go | GetCounterValue | func GetCounterValue(m prometheus.Counter) float64 {
var pm dto.Metric
err := m.Write(&pm)
if err == nil {
return *pm.Counter.Value
}
return 0
} | go | func GetCounterValue(m prometheus.Counter) float64 {
var pm dto.Metric
err := m.Write(&pm)
if err == nil {
return *pm.Counter.Value
}
return 0
} | [
"func",
"GetCounterValue",
"(",
"m",
"prometheus",
".",
"Counter",
")",
"float64",
"{",
"var",
"pm",
"dto",
".",
"Metric",
"\n",
"err",
":=",
"m",
".",
"Write",
"(",
"&",
"pm",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"*",
"pm",
".",
"Counter",
".",
"Value",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}"
] | // GetCounterValue returns the current value
// stored for the counter | [
"GetCounterValue",
"returns",
"the",
"current",
"value",
"stored",
"for",
"the",
"counter"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/metrics/metrics.go#L680-L687 |
163,404 | cilium/cilium | pkg/metrics/metrics.go | DumpMetrics | func DumpMetrics() ([]*models.Metric, error) {
result := []*models.Metric{}
currentMetrics, err := registry.Gather()
if err != nil {
return result, err
}
for _, val := range currentMetrics {
metricName := val.GetName()
metricType := val.GetType()
for _, metricLabel := range val.Metric {
labels := map[string]string{}
for _, label := range metricLabel.GetLabel() {
labels[label.GetName()] = label.GetValue()
}
var value float64
switch metricType {
case dto.MetricType_COUNTER:
value = metricLabel.Counter.GetValue()
case dto.MetricType_GAUGE:
value = metricLabel.GetGauge().GetValue()
case dto.MetricType_UNTYPED:
value = metricLabel.GetUntyped().GetValue()
case dto.MetricType_SUMMARY:
value = metricLabel.GetSummary().GetSampleSum()
case dto.MetricType_HISTOGRAM:
value = metricLabel.GetHistogram().GetSampleSum()
default:
continue
}
metric := &models.Metric{
Name: metricName,
Labels: labels,
Value: value,
}
result = append(result, metric)
}
}
return result, nil
} | go | func DumpMetrics() ([]*models.Metric, error) {
result := []*models.Metric{}
currentMetrics, err := registry.Gather()
if err != nil {
return result, err
}
for _, val := range currentMetrics {
metricName := val.GetName()
metricType := val.GetType()
for _, metricLabel := range val.Metric {
labels := map[string]string{}
for _, label := range metricLabel.GetLabel() {
labels[label.GetName()] = label.GetValue()
}
var value float64
switch metricType {
case dto.MetricType_COUNTER:
value = metricLabel.Counter.GetValue()
case dto.MetricType_GAUGE:
value = metricLabel.GetGauge().GetValue()
case dto.MetricType_UNTYPED:
value = metricLabel.GetUntyped().GetValue()
case dto.MetricType_SUMMARY:
value = metricLabel.GetSummary().GetSampleSum()
case dto.MetricType_HISTOGRAM:
value = metricLabel.GetHistogram().GetSampleSum()
default:
continue
}
metric := &models.Metric{
Name: metricName,
Labels: labels,
Value: value,
}
result = append(result, metric)
}
}
return result, nil
} | [
"func",
"DumpMetrics",
"(",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Metric",
",",
"error",
")",
"{",
"result",
":=",
"[",
"]",
"*",
"models",
".",
"Metric",
"{",
"}",
"\n",
"currentMetrics",
",",
"err",
":=",
"registry",
".",
"Gather",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"result",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"val",
":=",
"range",
"currentMetrics",
"{",
"metricName",
":=",
"val",
".",
"GetName",
"(",
")",
"\n",
"metricType",
":=",
"val",
".",
"GetType",
"(",
")",
"\n\n",
"for",
"_",
",",
"metricLabel",
":=",
"range",
"val",
".",
"Metric",
"{",
"labels",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"label",
":=",
"range",
"metricLabel",
".",
"GetLabel",
"(",
")",
"{",
"labels",
"[",
"label",
".",
"GetName",
"(",
")",
"]",
"=",
"label",
".",
"GetValue",
"(",
")",
"\n",
"}",
"\n\n",
"var",
"value",
"float64",
"\n",
"switch",
"metricType",
"{",
"case",
"dto",
".",
"MetricType_COUNTER",
":",
"value",
"=",
"metricLabel",
".",
"Counter",
".",
"GetValue",
"(",
")",
"\n",
"case",
"dto",
".",
"MetricType_GAUGE",
":",
"value",
"=",
"metricLabel",
".",
"GetGauge",
"(",
")",
".",
"GetValue",
"(",
")",
"\n",
"case",
"dto",
".",
"MetricType_UNTYPED",
":",
"value",
"=",
"metricLabel",
".",
"GetUntyped",
"(",
")",
".",
"GetValue",
"(",
")",
"\n",
"case",
"dto",
".",
"MetricType_SUMMARY",
":",
"value",
"=",
"metricLabel",
".",
"GetSummary",
"(",
")",
".",
"GetSampleSum",
"(",
")",
"\n",
"case",
"dto",
".",
"MetricType_HISTOGRAM",
":",
"value",
"=",
"metricLabel",
".",
"GetHistogram",
"(",
")",
".",
"GetSampleSum",
"(",
")",
"\n",
"default",
":",
"continue",
"\n",
"}",
"\n\n",
"metric",
":=",
"&",
"models",
".",
"Metric",
"{",
"Name",
":",
"metricName",
",",
"Labels",
":",
"labels",
",",
"Value",
":",
"value",
",",
"}",
"\n",
"result",
"=",
"append",
"(",
"result",
",",
"metric",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // DumpMetrics gets the current Cilium metrics and dumps all into a
// models.Metrics structure.If metrics cannot be retrieved, returns an error | [
"DumpMetrics",
"gets",
"the",
"current",
"Cilium",
"metrics",
"and",
"dumps",
"all",
"into",
"a",
"models",
".",
"Metrics",
"structure",
".",
"If",
"metrics",
"cannot",
"be",
"retrieved",
"returns",
"an",
"error"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/metrics/metrics.go#L691-L734 |
163,405 | cilium/cilium | pkg/policy/cidr.go | getPrefixesFromCIDR | func getPrefixesFromCIDR(cidrs api.CIDRSlice) []*net.IPNet {
result, _ := ip.ParseCIDRs(cidrs.StringSlice())
return result
} | go | func getPrefixesFromCIDR(cidrs api.CIDRSlice) []*net.IPNet {
result, _ := ip.ParseCIDRs(cidrs.StringSlice())
return result
} | [
"func",
"getPrefixesFromCIDR",
"(",
"cidrs",
"api",
".",
"CIDRSlice",
")",
"[",
"]",
"*",
"net",
".",
"IPNet",
"{",
"result",
",",
"_",
":=",
"ip",
".",
"ParseCIDRs",
"(",
"cidrs",
".",
"StringSlice",
"(",
")",
")",
"\n",
"return",
"result",
"\n",
"}"
] | // getPrefixesFromCIDR fetches all CIDRs referred to by the specified slice
// and returns them as regular golang CIDR objects. | [
"getPrefixesFromCIDR",
"fetches",
"all",
"CIDRs",
"referred",
"to",
"by",
"the",
"specified",
"slice",
"and",
"returns",
"them",
"as",
"regular",
"golang",
"CIDR",
"objects",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/cidr.go#L26-L29 |
163,406 | cilium/cilium | pkg/policy/cidr.go | GetPrefixesFromCIDRSet | func GetPrefixesFromCIDRSet(rules api.CIDRRuleSlice) []*net.IPNet {
cidrs := api.ComputeResultantCIDRSet(rules)
return getPrefixesFromCIDR(cidrs)
} | go | func GetPrefixesFromCIDRSet(rules api.CIDRRuleSlice) []*net.IPNet {
cidrs := api.ComputeResultantCIDRSet(rules)
return getPrefixesFromCIDR(cidrs)
} | [
"func",
"GetPrefixesFromCIDRSet",
"(",
"rules",
"api",
".",
"CIDRRuleSlice",
")",
"[",
"]",
"*",
"net",
".",
"IPNet",
"{",
"cidrs",
":=",
"api",
".",
"ComputeResultantCIDRSet",
"(",
"rules",
")",
"\n",
"return",
"getPrefixesFromCIDR",
"(",
"cidrs",
")",
"\n",
"}"
] | // GetPrefixesFromCIDRSet fetches all CIDRs referred to by the specified slice
// and returns them as regular golang CIDR objects.
//
// Assumes that validation already occurred on 'rules'. | [
"GetPrefixesFromCIDRSet",
"fetches",
"all",
"CIDRs",
"referred",
"to",
"by",
"the",
"specified",
"slice",
"and",
"returns",
"them",
"as",
"regular",
"golang",
"CIDR",
"objects",
".",
"Assumes",
"that",
"validation",
"already",
"occurred",
"on",
"rules",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/cidr.go#L35-L38 |
163,407 | cilium/cilium | pkg/policy/cidr.go | GetCIDRPrefixes | func GetCIDRPrefixes(rules api.Rules) []*net.IPNet {
if len(rules) == 0 {
return nil
}
res := make([]*net.IPNet, 0, 32)
for _, r := range rules {
for _, ir := range r.Ingress {
if len(ir.FromCIDR) > 0 {
res = append(res, getPrefixesFromCIDR(ir.FromCIDR)...)
}
if len(ir.FromCIDRSet) > 0 {
res = append(res, GetPrefixesFromCIDRSet(ir.FromCIDRSet)...)
}
}
for _, er := range r.Egress {
if len(er.ToCIDR) > 0 {
res = append(res, getPrefixesFromCIDR(er.ToCIDR)...)
}
if len(er.ToCIDRSet) > 0 {
res = append(res, GetPrefixesFromCIDRSet(er.ToCIDRSet)...)
}
}
}
return res
} | go | func GetCIDRPrefixes(rules api.Rules) []*net.IPNet {
if len(rules) == 0 {
return nil
}
res := make([]*net.IPNet, 0, 32)
for _, r := range rules {
for _, ir := range r.Ingress {
if len(ir.FromCIDR) > 0 {
res = append(res, getPrefixesFromCIDR(ir.FromCIDR)...)
}
if len(ir.FromCIDRSet) > 0 {
res = append(res, GetPrefixesFromCIDRSet(ir.FromCIDRSet)...)
}
}
for _, er := range r.Egress {
if len(er.ToCIDR) > 0 {
res = append(res, getPrefixesFromCIDR(er.ToCIDR)...)
}
if len(er.ToCIDRSet) > 0 {
res = append(res, GetPrefixesFromCIDRSet(er.ToCIDRSet)...)
}
}
}
return res
} | [
"func",
"GetCIDRPrefixes",
"(",
"rules",
"api",
".",
"Rules",
")",
"[",
"]",
"*",
"net",
".",
"IPNet",
"{",
"if",
"len",
"(",
"rules",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"res",
":=",
"make",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"0",
",",
"32",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"rules",
"{",
"for",
"_",
",",
"ir",
":=",
"range",
"r",
".",
"Ingress",
"{",
"if",
"len",
"(",
"ir",
".",
"FromCIDR",
")",
">",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"getPrefixesFromCIDR",
"(",
"ir",
".",
"FromCIDR",
")",
"...",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"ir",
".",
"FromCIDRSet",
")",
">",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"GetPrefixesFromCIDRSet",
"(",
"ir",
".",
"FromCIDRSet",
")",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"er",
":=",
"range",
"r",
".",
"Egress",
"{",
"if",
"len",
"(",
"er",
".",
"ToCIDR",
")",
">",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"getPrefixesFromCIDR",
"(",
"er",
".",
"ToCIDR",
")",
"...",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"er",
".",
"ToCIDRSet",
")",
">",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"GetPrefixesFromCIDRSet",
"(",
"er",
".",
"ToCIDRSet",
")",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // GetCIDRPrefixes runs through the specified 'rules' to find every reference
// to a CIDR in the rules, and returns a slice containing all of these CIDRs.
// Multiple rules referring to the same CIDR will result in multiple copies of
// the CIDR in the returned slice.
//
// Assumes that validation already occurred on 'rules'. | [
"GetCIDRPrefixes",
"runs",
"through",
"the",
"specified",
"rules",
"to",
"find",
"every",
"reference",
"to",
"a",
"CIDR",
"in",
"the",
"rules",
"and",
"returns",
"a",
"slice",
"containing",
"all",
"of",
"these",
"CIDRs",
".",
"Multiple",
"rules",
"referring",
"to",
"the",
"same",
"CIDR",
"will",
"result",
"in",
"multiple",
"copies",
"of",
"the",
"CIDR",
"in",
"the",
"returned",
"slice",
".",
"Assumes",
"that",
"validation",
"already",
"occurred",
"on",
"rules",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/cidr.go#L46-L70 |
163,408 | cilium/cilium | monitor/listener/listener.go | IsDisconnected | func IsDisconnected(err error) bool {
if err == nil {
return false
}
op, ok := err.(*net.OpError)
if !ok {
return false
}
syscerr, ok := op.Err.(*os.SyscallError)
if !ok {
return false
}
errn := syscerr.Err.(syscall.Errno)
return errn == syscall.EPIPE
} | go | func IsDisconnected(err error) bool {
if err == nil {
return false
}
op, ok := err.(*net.OpError)
if !ok {
return false
}
syscerr, ok := op.Err.(*os.SyscallError)
if !ok {
return false
}
errn := syscerr.Err.(syscall.Errno)
return errn == syscall.EPIPE
} | [
"func",
"IsDisconnected",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"op",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"net",
".",
"OpError",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"syscerr",
",",
"ok",
":=",
"op",
".",
"Err",
".",
"(",
"*",
"os",
".",
"SyscallError",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"errn",
":=",
"syscerr",
".",
"Err",
".",
"(",
"syscall",
".",
"Errno",
")",
"\n",
"return",
"errn",
"==",
"syscall",
".",
"EPIPE",
"\n",
"}"
] | // IsDisconnected is a convenience function that wraps the absurdly long set of
// checks for a disconnect. | [
"IsDisconnected",
"is",
"a",
"convenience",
"function",
"that",
"wraps",
"the",
"absurdly",
"long",
"set",
"of",
"checks",
"for",
"a",
"disconnect",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/monitor/listener/listener.go#L58-L75 |
163,409 | cilium/cilium | pkg/buildqueue/buildqueue.go | finish | func (b *buildGroup) finish(q *BuildQueue, buildStatus *buildStatus) {
q.mutex.Lock()
b.running--
buildStatus.currentBuild = nil
q.mutex.Unlock()
q.waitingBuilders.Broadcast()
} | go | func (b *buildGroup) finish(q *BuildQueue, buildStatus *buildStatus) {
q.mutex.Lock()
b.running--
buildStatus.currentBuild = nil
q.mutex.Unlock()
q.waitingBuilders.Broadcast()
} | [
"func",
"(",
"b",
"*",
"buildGroup",
")",
"finish",
"(",
"q",
"*",
"BuildQueue",
",",
"buildStatus",
"*",
"buildStatus",
")",
"{",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"b",
".",
"running",
"--",
"\n",
"buildStatus",
".",
"currentBuild",
"=",
"nil",
"\n",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"q",
".",
"waitingBuilders",
".",
"Broadcast",
"(",
")",
"\n",
"}"
] | // finish signals that a build of this buildGroup has completed | [
"finish",
"signals",
"that",
"a",
"build",
"of",
"this",
"buildGroup",
"has",
"completed"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L78-L85 |
163,410 | cilium/cilium | pkg/buildqueue/buildqueue.go | NewBuildQueue | func NewBuildQueue(name string) *BuildQueue {
q := &BuildQueue{
name: name,
buildStatus: buildStatusMap{},
workerBuildQueue: make(chan Builder, buildQueueSize),
stopWorker: make(chan struct{}, 0),
regularBuilds: buildGroup{
condition: func(q *BuildQueue) bool {
return q.exclusiveBuilds.waiting == 0 && q.exclusiveBuilds.running == 0
},
},
exclusiveBuilds: buildGroup{
condition: func(q *BuildQueue) bool {
return q.exclusiveBuilds.running == 0 && q.regularBuilds.running == 0
},
},
}
q.waitingBuilders = sync.NewCond(&q.mutex)
nWorkers := numWorkerThreads()
for w := 0; w < nWorkers; w++ {
go q.runWorker()
}
return q
} | go | func NewBuildQueue(name string) *BuildQueue {
q := &BuildQueue{
name: name,
buildStatus: buildStatusMap{},
workerBuildQueue: make(chan Builder, buildQueueSize),
stopWorker: make(chan struct{}, 0),
regularBuilds: buildGroup{
condition: func(q *BuildQueue) bool {
return q.exclusiveBuilds.waiting == 0 && q.exclusiveBuilds.running == 0
},
},
exclusiveBuilds: buildGroup{
condition: func(q *BuildQueue) bool {
return q.exclusiveBuilds.running == 0 && q.regularBuilds.running == 0
},
},
}
q.waitingBuilders = sync.NewCond(&q.mutex)
nWorkers := numWorkerThreads()
for w := 0; w < nWorkers; w++ {
go q.runWorker()
}
return q
} | [
"func",
"NewBuildQueue",
"(",
"name",
"string",
")",
"*",
"BuildQueue",
"{",
"q",
":=",
"&",
"BuildQueue",
"{",
"name",
":",
"name",
",",
"buildStatus",
":",
"buildStatusMap",
"{",
"}",
",",
"workerBuildQueue",
":",
"make",
"(",
"chan",
"Builder",
",",
"buildQueueSize",
")",
",",
"stopWorker",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
",",
"regularBuilds",
":",
"buildGroup",
"{",
"condition",
":",
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"bool",
"{",
"return",
"q",
".",
"exclusiveBuilds",
".",
"waiting",
"==",
"0",
"&&",
"q",
".",
"exclusiveBuilds",
".",
"running",
"==",
"0",
"\n",
"}",
",",
"}",
",",
"exclusiveBuilds",
":",
"buildGroup",
"{",
"condition",
":",
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"bool",
"{",
"return",
"q",
".",
"exclusiveBuilds",
".",
"running",
"==",
"0",
"&&",
"q",
".",
"regularBuilds",
".",
"running",
"==",
"0",
"\n",
"}",
",",
"}",
",",
"}",
"\n\n",
"q",
".",
"waitingBuilders",
"=",
"sync",
".",
"NewCond",
"(",
"&",
"q",
".",
"mutex",
")",
"\n\n",
"nWorkers",
":=",
"numWorkerThreads",
"(",
")",
"\n",
"for",
"w",
":=",
"0",
";",
"w",
"<",
"nWorkers",
";",
"w",
"++",
"{",
"go",
"q",
".",
"runWorker",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"q",
"\n",
"}"
] | // NewBuildQueue returns a new build queue | [
"NewBuildQueue",
"returns",
"a",
"new",
"build",
"queue"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L120-L146 |
163,411 | cilium/cilium | pkg/buildqueue/buildqueue.go | Stop | func (q *BuildQueue) Stop() {
close(q.stopWorker)
waitForCleanup := sync.WaitGroup{}
q.mutex.Lock()
for _, status := range q.buildStatus {
waitForCleanup.Add(1)
go func(b Builder) {
q.Drain(b)
waitForCleanup.Done()
}(status.builder)
}
q.mutex.Unlock()
waitForCleanup.Wait()
} | go | func (q *BuildQueue) Stop() {
close(q.stopWorker)
waitForCleanup := sync.WaitGroup{}
q.mutex.Lock()
for _, status := range q.buildStatus {
waitForCleanup.Add(1)
go func(b Builder) {
q.Drain(b)
waitForCleanup.Done()
}(status.builder)
}
q.mutex.Unlock()
waitForCleanup.Wait()
} | [
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"Stop",
"(",
")",
"{",
"close",
"(",
"q",
".",
"stopWorker",
")",
"\n\n",
"waitForCleanup",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n\n",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"status",
":=",
"range",
"q",
".",
"buildStatus",
"{",
"waitForCleanup",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
"b",
"Builder",
")",
"{",
"q",
".",
"Drain",
"(",
"b",
")",
"\n",
"waitForCleanup",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
"status",
".",
"builder",
")",
"\n",
"}",
"\n",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"waitForCleanup",
".",
"Wait",
"(",
")",
"\n",
"}"
] | // Stop stops the build queue and terminates all workers | [
"Stop",
"stops",
"the",
"build",
"queue",
"and",
"terminates",
"all",
"workers"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L149-L165 |
163,412 | cilium/cilium | pkg/buildqueue/buildqueue.go | createAndAddNotificationChannel | func (b *build) createAndAddNotificationChannel() BuildNotification {
notify := newBuildNotification()
b.notificationChannels = append(b.notificationChannels, notify)
return notify
} | go | func (b *build) createAndAddNotificationChannel() BuildNotification {
notify := newBuildNotification()
b.notificationChannels = append(b.notificationChannels, notify)
return notify
} | [
"func",
"(",
"b",
"*",
"build",
")",
"createAndAddNotificationChannel",
"(",
")",
"BuildNotification",
"{",
"notify",
":=",
"newBuildNotification",
"(",
")",
"\n",
"b",
".",
"notificationChannels",
"=",
"append",
"(",
"b",
".",
"notificationChannels",
",",
"notify",
")",
"\n",
"return",
"notify",
"\n",
"}"
] | // createAndAddNotificationChannel creates and adds a build notification
// channel. This function may only be called while the build is not yet in
// progress. | [
"createAndAddNotificationChannel",
"creates",
"and",
"adds",
"a",
"build",
"notification",
"channel",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"while",
"the",
"build",
"is",
"not",
"yet",
"in",
"progress",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L229-L233 |
163,413 | cilium/cilium | pkg/buildqueue/buildqueue.go | reportStatus | func (b *build) reportStatus(q *BuildQueue, success bool) {
for _, notify := range b.notificationChannels {
notify <- success
close(notify)
}
} | go | func (b *build) reportStatus(q *BuildQueue, success bool) {
for _, notify := range b.notificationChannels {
notify <- success
close(notify)
}
} | [
"func",
"(",
"b",
"*",
"build",
")",
"reportStatus",
"(",
"q",
"*",
"BuildQueue",
",",
"success",
"bool",
")",
"{",
"for",
"_",
",",
"notify",
":=",
"range",
"b",
".",
"notificationChannels",
"{",
"notify",
"<-",
"success",
"\n",
"close",
"(",
"notify",
")",
"\n",
"}",
"\n",
"}"
] | // reportStatus reports the status of a build to all notification channels.
// This function may only be called if the build is the currentBuild. It may
// never be called while the build is still assigned to nextBuild. | [
"reportStatus",
"reports",
"the",
"status",
"of",
"a",
"build",
"to",
"all",
"notification",
"channels",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"if",
"the",
"build",
"is",
"the",
"currentBuild",
".",
"It",
"may",
"never",
"be",
"called",
"while",
"the",
"build",
"is",
"still",
"assigned",
"to",
"nextBuild",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L238-L243 |
163,414 | cilium/cilium | pkg/buildqueue/buildqueue.go | cancelScheduled | func (b *build) cancelScheduled(q *BuildQueue) int {
numBuilds := b.numFolded()
metrics.BuildQueueEntries.With(map[string]string{
metrics.LabelBuildQueueName: q.name,
metrics.LabelBuildState: metrics.BuildStateWaiting,
}).Sub(float64(numBuilds))
b.reportStatus(q, false)
return numBuilds
} | go | func (b *build) cancelScheduled(q *BuildQueue) int {
numBuilds := b.numFolded()
metrics.BuildQueueEntries.With(map[string]string{
metrics.LabelBuildQueueName: q.name,
metrics.LabelBuildState: metrics.BuildStateWaiting,
}).Sub(float64(numBuilds))
b.reportStatus(q, false)
return numBuilds
} | [
"func",
"(",
"b",
"*",
"build",
")",
"cancelScheduled",
"(",
"q",
"*",
"BuildQueue",
")",
"int",
"{",
"numBuilds",
":=",
"b",
".",
"numFolded",
"(",
")",
"\n\n",
"metrics",
".",
"BuildQueueEntries",
".",
"With",
"(",
"map",
"[",
"string",
"]",
"string",
"{",
"metrics",
".",
"LabelBuildQueueName",
":",
"q",
".",
"name",
",",
"metrics",
".",
"LabelBuildState",
":",
"metrics",
".",
"BuildStateWaiting",
",",
"}",
")",
".",
"Sub",
"(",
"float64",
"(",
"numBuilds",
")",
")",
"\n\n",
"b",
".",
"reportStatus",
"(",
"q",
",",
"false",
")",
"\n\n",
"return",
"numBuilds",
"\n",
"}"
] | // cancel cancels a scheduled and not yet running build. q.mutex must be held. | [
"cancel",
"cancels",
"a",
"scheduled",
"and",
"not",
"yet",
"running",
"build",
".",
"q",
".",
"mutex",
"must",
"be",
"held",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L246-L257 |
163,415 | cilium/cilium | pkg/buildqueue/buildqueue.go | Remove | func (q *BuildQueue) Remove(b Buildable) {
uuid := b.GetUUID()
q.mutex.Lock()
if status, ok := q.buildStatus[uuid]; ok {
// Only remove the builder UUID from the buildStatus if no
// build is currently running. If a build is running, the
// buildStatus continue to be in place until the build has
// completed.
if status.currentBuild == nil {
delete(q.buildStatus, uuid)
}
if status.nextBuild != nil {
num := status.nextBuild.cancelScheduled(q)
defer status.builder.BuildsDequeued(num, true)
}
}
q.mutex.Unlock()
} | go | func (q *BuildQueue) Remove(b Buildable) {
uuid := b.GetUUID()
q.mutex.Lock()
if status, ok := q.buildStatus[uuid]; ok {
// Only remove the builder UUID from the buildStatus if no
// build is currently running. If a build is running, the
// buildStatus continue to be in place until the build has
// completed.
if status.currentBuild == nil {
delete(q.buildStatus, uuid)
}
if status.nextBuild != nil {
num := status.nextBuild.cancelScheduled(q)
defer status.builder.BuildsDequeued(num, true)
}
}
q.mutex.Unlock()
} | [
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"Remove",
"(",
"b",
"Buildable",
")",
"{",
"uuid",
":=",
"b",
".",
"GetUUID",
"(",
")",
"\n",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"status",
",",
"ok",
":=",
"q",
".",
"buildStatus",
"[",
"uuid",
"]",
";",
"ok",
"{",
"// Only remove the builder UUID from the buildStatus if no",
"// build is currently running. If a build is running, the",
"// buildStatus continue to be in place until the build has",
"// completed.",
"if",
"status",
".",
"currentBuild",
"==",
"nil",
"{",
"delete",
"(",
"q",
".",
"buildStatus",
",",
"uuid",
")",
"\n",
"}",
"\n\n",
"if",
"status",
".",
"nextBuild",
"!=",
"nil",
"{",
"num",
":=",
"status",
".",
"nextBuild",
".",
"cancelScheduled",
"(",
"q",
")",
"\n",
"defer",
"status",
".",
"builder",
".",
"BuildsDequeued",
"(",
"num",
",",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Remove removes the builder from the queue. | [
"Remove",
"removes",
"the",
"builder",
"from",
"the",
"queue",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L373-L391 |
163,416 | cilium/cilium | pkg/buildqueue/buildqueue.go | Drain | func (q *BuildQueue) Drain(b Buildable) bool {
uuid := b.GetUUID()
waited := false
q.mutex.Lock()
status, ok := q.buildStatus[uuid]
if ok {
if status.nextBuild != nil {
num := status.nextBuild.cancelScheduled(q)
status.nextBuild = nil
defer status.builder.BuildsDequeued(num, true)
}
for status.currentBuild != nil {
waited = true
q.waitingBuilders.Wait()
}
delete(q.buildStatus, uuid)
}
q.mutex.Unlock()
return waited
} | go | func (q *BuildQueue) Drain(b Buildable) bool {
uuid := b.GetUUID()
waited := false
q.mutex.Lock()
status, ok := q.buildStatus[uuid]
if ok {
if status.nextBuild != nil {
num := status.nextBuild.cancelScheduled(q)
status.nextBuild = nil
defer status.builder.BuildsDequeued(num, true)
}
for status.currentBuild != nil {
waited = true
q.waitingBuilders.Wait()
}
delete(q.buildStatus, uuid)
}
q.mutex.Unlock()
return waited
} | [
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"Drain",
"(",
"b",
"Buildable",
")",
"bool",
"{",
"uuid",
":=",
"b",
".",
"GetUUID",
"(",
")",
"\n",
"waited",
":=",
"false",
"\n\n",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"status",
",",
"ok",
":=",
"q",
".",
"buildStatus",
"[",
"uuid",
"]",
"\n",
"if",
"ok",
"{",
"if",
"status",
".",
"nextBuild",
"!=",
"nil",
"{",
"num",
":=",
"status",
".",
"nextBuild",
".",
"cancelScheduled",
"(",
"q",
")",
"\n",
"status",
".",
"nextBuild",
"=",
"nil",
"\n",
"defer",
"status",
".",
"builder",
".",
"BuildsDequeued",
"(",
"num",
",",
"true",
")",
"\n",
"}",
"\n\n",
"for",
"status",
".",
"currentBuild",
"!=",
"nil",
"{",
"waited",
"=",
"true",
"\n",
"q",
".",
"waitingBuilders",
".",
"Wait",
"(",
")",
"\n",
"}",
"\n\n",
"delete",
"(",
"q",
".",
"buildStatus",
",",
"uuid",
")",
"\n",
"}",
"\n\n",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"waited",
"\n",
"}"
] | // Drain will drain the queue from any running or scheduled builds of a
// Buildable. If a build is running, the function will block for the build to
// complete. It is the responsibility of the caller that the Buildable does not
// get re-scheduled during the draining. Returns true if waiting was required. | [
"Drain",
"will",
"drain",
"the",
"queue",
"from",
"any",
"running",
"or",
"scheduled",
"builds",
"of",
"a",
"Buildable",
".",
"If",
"a",
"build",
"is",
"running",
"the",
"function",
"will",
"block",
"for",
"the",
"build",
"to",
"complete",
".",
"It",
"is",
"the",
"responsibility",
"of",
"the",
"caller",
"that",
"the",
"Buildable",
"does",
"not",
"get",
"re",
"-",
"scheduled",
"during",
"the",
"draining",
".",
"Returns",
"true",
"if",
"waiting",
"was",
"required",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L397-L420 |
163,417 | cilium/cilium | pkg/buildqueue/buildqueue.go | checkBuildGuarantees | func (q *BuildQueue) checkBuildGuarantees() error {
q.mutex.Lock()
defer q.mutex.Unlock()
buildCount := map[string]int{}
for _, status := range q.buildStatus {
if build := status.currentBuild; build != nil {
buildCount[build.uuid]++
}
}
switch {
case q.exclusiveBuilds.running > 1:
return fmt.Errorf("More than one exclusive build is running")
case q.exclusiveBuilds.running > 0 && q.regularBuilds.running > 0:
return fmt.Errorf("Exclusive build is running in parallel with regular build")
default:
for uuid, count := range buildCount {
if count > 1 {
return fmt.Errorf("UUID %s is being built in parallel", uuid)
}
}
}
return nil
} | go | func (q *BuildQueue) checkBuildGuarantees() error {
q.mutex.Lock()
defer q.mutex.Unlock()
buildCount := map[string]int{}
for _, status := range q.buildStatus {
if build := status.currentBuild; build != nil {
buildCount[build.uuid]++
}
}
switch {
case q.exclusiveBuilds.running > 1:
return fmt.Errorf("More than one exclusive build is running")
case q.exclusiveBuilds.running > 0 && q.regularBuilds.running > 0:
return fmt.Errorf("Exclusive build is running in parallel with regular build")
default:
for uuid, count := range buildCount {
if count > 1 {
return fmt.Errorf("UUID %s is being built in parallel", uuid)
}
}
}
return nil
} | [
"func",
"(",
"q",
"*",
"BuildQueue",
")",
"checkBuildGuarantees",
"(",
")",
"error",
"{",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"buildCount",
":=",
"map",
"[",
"string",
"]",
"int",
"{",
"}",
"\n\n",
"for",
"_",
",",
"status",
":=",
"range",
"q",
".",
"buildStatus",
"{",
"if",
"build",
":=",
"status",
".",
"currentBuild",
";",
"build",
"!=",
"nil",
"{",
"buildCount",
"[",
"build",
".",
"uuid",
"]",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"q",
".",
"exclusiveBuilds",
".",
"running",
">",
"1",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"q",
".",
"exclusiveBuilds",
".",
"running",
">",
"0",
"&&",
"q",
".",
"regularBuilds",
".",
"running",
">",
"0",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"for",
"uuid",
",",
"count",
":=",
"range",
"buildCount",
"{",
"if",
"count",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"uuid",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // checkBuildGuarantees reports errors when build conditions are currently not
// being respected. This function is used for unit testing. | [
"checkBuildGuarantees",
"reports",
"errors",
"when",
"build",
"conditions",
"are",
"currently",
"not",
"being",
"respected",
".",
"This",
"function",
"is",
"used",
"for",
"unit",
"testing",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/buildqueue/buildqueue.go#L569-L595 |
163,418 | cilium/cilium | api/v1/health/server/restapi/connectivity/get_status.go | NewGetStatus | func NewGetStatus(ctx *middleware.Context, handler GetStatusHandler) *GetStatus {
return &GetStatus{Context: ctx, Handler: handler}
} | go | func NewGetStatus(ctx *middleware.Context, handler GetStatusHandler) *GetStatus {
return &GetStatus{Context: ctx, Handler: handler}
} | [
"func",
"NewGetStatus",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetStatusHandler",
")",
"*",
"GetStatus",
"{",
"return",
"&",
"GetStatus",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetStatus creates a new http.Handler for the get status operation | [
"NewGetStatus",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"status",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/connectivity/get_status.go#L28-L30 |
163,419 | cilium/cilium | pkg/maps/policymap/callmap.go | RemoveGlobalMapping | func RemoveGlobalMapping(id uint32) error {
gpm, err := OpenCallMap()
if err == nil {
k := plumbingKey{
key: id,
}
err = gpm.Map.Delete(&k)
gpm.Close()
}
return err
} | go | func RemoveGlobalMapping(id uint32) error {
gpm, err := OpenCallMap()
if err == nil {
k := plumbingKey{
key: id,
}
err = gpm.Map.Delete(&k)
gpm.Close()
}
return err
} | [
"func",
"RemoveGlobalMapping",
"(",
"id",
"uint32",
")",
"error",
"{",
"gpm",
",",
"err",
":=",
"OpenCallMap",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"k",
":=",
"plumbingKey",
"{",
"key",
":",
"id",
",",
"}",
"\n",
"err",
"=",
"gpm",
".",
"Map",
".",
"Delete",
"(",
"&",
"k",
")",
"\n",
"gpm",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] | // RemoveGlobalMapping removes the mapping from the specified endpoint ID to
// the BPF policy program for that endpoint. | [
"RemoveGlobalMapping",
"removes",
"the",
"mapping",
"from",
"the",
"specified",
"endpoint",
"ID",
"to",
"the",
"BPF",
"policy",
"program",
"for",
"that",
"endpoint",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/policymap/callmap.go#L53-L64 |
163,420 | cilium/cilium | pkg/maps/policymap/callmap.go | OpenCallMap | func OpenCallMap() (*PolicyPlumbingMap, error) {
m, err := bpf.OpenMap(CallMapName)
if err != nil {
return nil, err
}
return &PolicyPlumbingMap{Map: m}, nil
} | go | func OpenCallMap() (*PolicyPlumbingMap, error) {
m, err := bpf.OpenMap(CallMapName)
if err != nil {
return nil, err
}
return &PolicyPlumbingMap{Map: m}, nil
} | [
"func",
"OpenCallMap",
"(",
")",
"(",
"*",
"PolicyPlumbingMap",
",",
"error",
")",
"{",
"m",
",",
"err",
":=",
"bpf",
".",
"OpenMap",
"(",
"CallMapName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"PolicyPlumbingMap",
"{",
"Map",
":",
"m",
"}",
",",
"nil",
"\n",
"}"
] | // OpenCallMap opens the map that maps endpoint IDs to program file
// descriptors, which allows tail calling into the policy datapath code from
// other BPF programs. | [
"OpenCallMap",
"opens",
"the",
"map",
"that",
"maps",
"endpoint",
"IDs",
"to",
"program",
"file",
"descriptors",
"which",
"allows",
"tail",
"calling",
"into",
"the",
"policy",
"datapath",
"code",
"from",
"other",
"BPF",
"programs",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/policymap/callmap.go#L69-L75 |
163,421 | cilium/cilium | api/v1/server/restapi/daemon/get_config_responses.go | WithPayload | func (o *GetConfigOK) WithPayload(payload *models.DaemonConfiguration) *GetConfigOK {
o.Payload = payload
return o
} | go | func (o *GetConfigOK) WithPayload(payload *models.DaemonConfiguration) *GetConfigOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetConfigOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"DaemonConfiguration",
")",
"*",
"GetConfigOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get config o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"config",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/daemon/get_config_responses.go#L38-L41 |
163,422 | cilium/cilium | pkg/maps/tunnel/tunnel.go | NewTunnelMap | func NewTunnelMap(name string) *Map {
return &Map{Map: bpf.NewMap(MapName,
bpf.MapTypeHash,
int(unsafe.Sizeof(TunnelEndpoint{})),
int(unsafe.Sizeof(TunnelEndpoint{})),
MaxEntries,
0, 0,
func(key []byte, value []byte) (bpf.MapKey, bpf.MapValue, error) {
k, v := TunnelEndpoint{}, TunnelEndpoint{}
if err := bpf.ConvertKeyValue(key, value, &k, &v); err != nil {
return nil, nil, err
}
return &k, &v, nil
}).WithCache(),
}
} | go | func NewTunnelMap(name string) *Map {
return &Map{Map: bpf.NewMap(MapName,
bpf.MapTypeHash,
int(unsafe.Sizeof(TunnelEndpoint{})),
int(unsafe.Sizeof(TunnelEndpoint{})),
MaxEntries,
0, 0,
func(key []byte, value []byte) (bpf.MapKey, bpf.MapValue, error) {
k, v := TunnelEndpoint{}, TunnelEndpoint{}
if err := bpf.ConvertKeyValue(key, value, &k, &v); err != nil {
return nil, nil, err
}
return &k, &v, nil
}).WithCache(),
}
} | [
"func",
"NewTunnelMap",
"(",
"name",
"string",
")",
"*",
"Map",
"{",
"return",
"&",
"Map",
"{",
"Map",
":",
"bpf",
".",
"NewMap",
"(",
"MapName",
",",
"bpf",
".",
"MapTypeHash",
",",
"int",
"(",
"unsafe",
".",
"Sizeof",
"(",
"TunnelEndpoint",
"{",
"}",
")",
")",
",",
"int",
"(",
"unsafe",
".",
"Sizeof",
"(",
"TunnelEndpoint",
"{",
"}",
")",
")",
",",
"MaxEntries",
",",
"0",
",",
"0",
",",
"func",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"bpf",
".",
"MapKey",
",",
"bpf",
".",
"MapValue",
",",
"error",
")",
"{",
"k",
",",
"v",
":=",
"TunnelEndpoint",
"{",
"}",
",",
"TunnelEndpoint",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"bpf",
".",
"ConvertKeyValue",
"(",
"key",
",",
"value",
",",
"&",
"k",
",",
"&",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"k",
",",
"&",
"v",
",",
"nil",
"\n",
"}",
")",
".",
"WithCache",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewTunnelMap returns a new tunnel map with the specified name. | [
"NewTunnelMap",
"returns",
"a",
"new",
"tunnel",
"map",
"with",
"the",
"specified",
"name",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/tunnel/tunnel.go#L44-L61 |
163,423 | cilium/cilium | pkg/maps/tunnel/tunnel.go | GetTunnelEndpoint | func (m *Map) GetTunnelEndpoint(prefix net.IP) (net.IP, error) {
val, err := TunnelMap.Lookup(newTunnelEndpoint(prefix))
if err != nil {
return net.IP{}, err
}
return val.(*TunnelEndpoint).ToIP(), nil
} | go | func (m *Map) GetTunnelEndpoint(prefix net.IP) (net.IP, error) {
val, err := TunnelMap.Lookup(newTunnelEndpoint(prefix))
if err != nil {
return net.IP{}, err
}
return val.(*TunnelEndpoint).ToIP(), nil
} | [
"func",
"(",
"m",
"*",
"Map",
")",
"GetTunnelEndpoint",
"(",
"prefix",
"net",
".",
"IP",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"val",
",",
"err",
":=",
"TunnelMap",
".",
"Lookup",
"(",
"newTunnelEndpoint",
"(",
"prefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"net",
".",
"IP",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"val",
".",
"(",
"*",
"TunnelEndpoint",
")",
".",
"ToIP",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GetTunnelEndpoint removes a prefix => tunnel-endpoint mapping | [
"GetTunnelEndpoint",
"removes",
"a",
"prefix",
"=",
">",
"tunnel",
"-",
"endpoint",
"mapping"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/tunnel/tunnel.go#L93-L100 |
163,424 | cilium/cilium | pkg/maps/tunnel/tunnel.go | DeleteTunnelEndpoint | func (m *Map) DeleteTunnelEndpoint(prefix net.IP) error {
log.WithField(fieldPrefix, prefix).Debug("Deleting tunnel map entry")
return TunnelMap.Delete(newTunnelEndpoint(prefix))
} | go | func (m *Map) DeleteTunnelEndpoint(prefix net.IP) error {
log.WithField(fieldPrefix, prefix).Debug("Deleting tunnel map entry")
return TunnelMap.Delete(newTunnelEndpoint(prefix))
} | [
"func",
"(",
"m",
"*",
"Map",
")",
"DeleteTunnelEndpoint",
"(",
"prefix",
"net",
".",
"IP",
")",
"error",
"{",
"log",
".",
"WithField",
"(",
"fieldPrefix",
",",
"prefix",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"TunnelMap",
".",
"Delete",
"(",
"newTunnelEndpoint",
"(",
"prefix",
")",
")",
"\n",
"}"
] | // DeleteTunnelEndpoint removes a prefix => tunnel-endpoint mapping | [
"DeleteTunnelEndpoint",
"removes",
"a",
"prefix",
"=",
">",
"tunnel",
"-",
"endpoint",
"mapping"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/tunnel/tunnel.go#L103-L106 |
163,425 | cilium/cilium | api/v1/models/b_p_f_map.go | Validate | func (m *BPFMap) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCache(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *BPFMap) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCache(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"BPFMap",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCache",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this b p f map | [
"Validate",
"validates",
"this",
"b",
"p",
"f",
"map"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/b_p_f_map.go#L29-L40 |
163,426 | cilium/cilium | daemon/state.go | validateEndpoint | func (d *Daemon) validateEndpoint(ep *endpoint.Endpoint) (valid bool, err error) {
// On each restart, the health endpoint is supposed to be recreated.
// Hence we need to clean health endpoint state unconditionally.
if ep.HasLabels(labels.LabelHealth) {
// Ignore health endpoint and don't report
// it as not restored. But we need to clean up the old
// state files, so do this now.
healthStateDir := ep.StateDirectoryPath()
scopedLog := log.WithFields(logrus.Fields{
logfields.EndpointID: ep.ID,
logfields.Path: healthStateDir,
})
scopedLog.Debug("Removing old health endpoint state directory")
if err := os.RemoveAll(healthStateDir); err != nil {
scopedLog.Warning("Cannot clean up old health state directory")
}
return false, nil
}
if ep.K8sPodName != "" && ep.K8sNamespace != "" && k8s.IsEnabled() {
_, err := k8s.Client().CoreV1().Pods(ep.K8sNamespace).Get(ep.K8sPodName, meta_v1.GetOptions{})
if err != nil && k8serrors.IsNotFound(err) {
return false, fmt.Errorf("kubernetes pod not found")
}
}
if ep.HasIpvlanDataPath() {
// FIXME: We cannot check whether ipvlan slave netdev exists,
// because it requires entering container netns which is not
// always accessible (e.g. in k8s case "/proc" has to be bind
// mounted). Instead, we check whether the tail call map exists.
if _, err := os.Stat(ep.BPFIpvlanMapPath()); err != nil {
return false, fmt.Errorf("tail call map for IPvlan unavailable: %s", err)
}
} else if _, err := netlink.LinkByName(ep.IfName); err != nil {
return false, fmt.Errorf("interface %s could not be found", ep.IfName)
}
if option.Config.WorkloadsEnabled() && !workloads.IsRunning(ep) {
return false, fmt.Errorf("no workload could be associated with endpoint")
}
if err := d.allocateIPsLocked(ep); err != nil {
return false, fmt.Errorf("Failed to re-allocate IP of endpoint: %s", err)
}
return true, nil
} | go | func (d *Daemon) validateEndpoint(ep *endpoint.Endpoint) (valid bool, err error) {
// On each restart, the health endpoint is supposed to be recreated.
// Hence we need to clean health endpoint state unconditionally.
if ep.HasLabels(labels.LabelHealth) {
// Ignore health endpoint and don't report
// it as not restored. But we need to clean up the old
// state files, so do this now.
healthStateDir := ep.StateDirectoryPath()
scopedLog := log.WithFields(logrus.Fields{
logfields.EndpointID: ep.ID,
logfields.Path: healthStateDir,
})
scopedLog.Debug("Removing old health endpoint state directory")
if err := os.RemoveAll(healthStateDir); err != nil {
scopedLog.Warning("Cannot clean up old health state directory")
}
return false, nil
}
if ep.K8sPodName != "" && ep.K8sNamespace != "" && k8s.IsEnabled() {
_, err := k8s.Client().CoreV1().Pods(ep.K8sNamespace).Get(ep.K8sPodName, meta_v1.GetOptions{})
if err != nil && k8serrors.IsNotFound(err) {
return false, fmt.Errorf("kubernetes pod not found")
}
}
if ep.HasIpvlanDataPath() {
// FIXME: We cannot check whether ipvlan slave netdev exists,
// because it requires entering container netns which is not
// always accessible (e.g. in k8s case "/proc" has to be bind
// mounted). Instead, we check whether the tail call map exists.
if _, err := os.Stat(ep.BPFIpvlanMapPath()); err != nil {
return false, fmt.Errorf("tail call map for IPvlan unavailable: %s", err)
}
} else if _, err := netlink.LinkByName(ep.IfName); err != nil {
return false, fmt.Errorf("interface %s could not be found", ep.IfName)
}
if option.Config.WorkloadsEnabled() && !workloads.IsRunning(ep) {
return false, fmt.Errorf("no workload could be associated with endpoint")
}
if err := d.allocateIPsLocked(ep); err != nil {
return false, fmt.Errorf("Failed to re-allocate IP of endpoint: %s", err)
}
return true, nil
} | [
"func",
"(",
"d",
"*",
"Daemon",
")",
"validateEndpoint",
"(",
"ep",
"*",
"endpoint",
".",
"Endpoint",
")",
"(",
"valid",
"bool",
",",
"err",
"error",
")",
"{",
"// On each restart, the health endpoint is supposed to be recreated.",
"// Hence we need to clean health endpoint state unconditionally.",
"if",
"ep",
".",
"HasLabels",
"(",
"labels",
".",
"LabelHealth",
")",
"{",
"// Ignore health endpoint and don't report",
"// it as not restored. But we need to clean up the old",
"// state files, so do this now.",
"healthStateDir",
":=",
"ep",
".",
"StateDirectoryPath",
"(",
")",
"\n",
"scopedLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"EndpointID",
":",
"ep",
".",
"ID",
",",
"logfields",
".",
"Path",
":",
"healthStateDir",
",",
"}",
")",
"\n",
"scopedLog",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"RemoveAll",
"(",
"healthStateDir",
")",
";",
"err",
"!=",
"nil",
"{",
"scopedLog",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"ep",
".",
"K8sPodName",
"!=",
"\"",
"\"",
"&&",
"ep",
".",
"K8sNamespace",
"!=",
"\"",
"\"",
"&&",
"k8s",
".",
"IsEnabled",
"(",
")",
"{",
"_",
",",
"err",
":=",
"k8s",
".",
"Client",
"(",
")",
".",
"CoreV1",
"(",
")",
".",
"Pods",
"(",
"ep",
".",
"K8sNamespace",
")",
".",
"Get",
"(",
"ep",
".",
"K8sPodName",
",",
"meta_v1",
".",
"GetOptions",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"k8serrors",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"ep",
".",
"HasIpvlanDataPath",
"(",
")",
"{",
"// FIXME: We cannot check whether ipvlan slave netdev exists,",
"// because it requires entering container netns which is not",
"// always accessible (e.g. in k8s case \"/proc\" has to be bind",
"// mounted). Instead, we check whether the tail call map exists.",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"ep",
".",
"BPFIpvlanMapPath",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"_",
",",
"err",
":=",
"netlink",
".",
"LinkByName",
"(",
"ep",
".",
"IfName",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ep",
".",
"IfName",
")",
"\n",
"}",
"\n\n",
"if",
"option",
".",
"Config",
".",
"WorkloadsEnabled",
"(",
")",
"&&",
"!",
"workloads",
".",
"IsRunning",
"(",
"ep",
")",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"allocateIPsLocked",
"(",
"ep",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // validateEndpoint attempts to determine that the endpoint is valid, ie it
// still exists in k8s, its datapath devices are present, and Cilium is
// responsible for its workload, etc.
//
// Returns true to indicate that the endpoint is valid to restore, and an
// optional error. | [
"validateEndpoint",
"attempts",
"to",
"determine",
"that",
"the",
"endpoint",
"is",
"valid",
"ie",
"it",
"still",
"exists",
"in",
"k8s",
"its",
"datapath",
"devices",
"are",
"present",
"and",
"Cilium",
"is",
"responsible",
"for",
"its",
"workload",
"etc",
".",
"Returns",
"true",
"to",
"indicate",
"that",
"the",
"endpoint",
"is",
"valid",
"to",
"restore",
"and",
"an",
"optional",
"error",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/daemon/state.go#L57-L104 |
163,427 | cilium/cilium | proxylib/proxylib/connection.go | advanceInput | func advanceInput(input [][]byte, bytes int) [][]byte {
for bytes > 0 && len(input) > 0 {
rem := len(input[0]) // this much data left in the first slice
if bytes < rem {
input[0] = input[0][bytes:] // skip 'bytes' bytes
bytes = 0
} else { // go to the beginning of the next unit
bytes -= rem
input = input[1:] // may result in an empty slice
}
}
return input
} | go | func advanceInput(input [][]byte, bytes int) [][]byte {
for bytes > 0 && len(input) > 0 {
rem := len(input[0]) // this much data left in the first slice
if bytes < rem {
input[0] = input[0][bytes:] // skip 'bytes' bytes
bytes = 0
} else { // go to the beginning of the next unit
bytes -= rem
input = input[1:] // may result in an empty slice
}
}
return input
} | [
"func",
"advanceInput",
"(",
"input",
"[",
"]",
"[",
"]",
"byte",
",",
"bytes",
"int",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"for",
"bytes",
">",
"0",
"&&",
"len",
"(",
"input",
")",
">",
"0",
"{",
"rem",
":=",
"len",
"(",
"input",
"[",
"0",
"]",
")",
"// this much data left in the first slice",
"\n",
"if",
"bytes",
"<",
"rem",
"{",
"input",
"[",
"0",
"]",
"=",
"input",
"[",
"0",
"]",
"[",
"bytes",
":",
"]",
"// skip 'bytes' bytes",
"\n",
"bytes",
"=",
"0",
"\n",
"}",
"else",
"{",
"// go to the beginning of the next unit",
"bytes",
"-=",
"rem",
"\n",
"input",
"=",
"input",
"[",
"1",
":",
"]",
"// may result in an empty slice",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"input",
"\n",
"}"
] | // Skip bytes in input, or exhaust the input. | [
"Skip",
"bytes",
"in",
"input",
"or",
"exhaust",
"the",
"input",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/proxylib/connection.go#L103-L115 |
163,428 | cilium/cilium | proxylib/proxylib/connection.go | getInjectBuf | func (connection *Connection) getInjectBuf(reply bool) InjectBuf {
if reply {
return connection.ReplyBuf
}
return connection.OrigBuf
} | go | func (connection *Connection) getInjectBuf(reply bool) InjectBuf {
if reply {
return connection.ReplyBuf
}
return connection.OrigBuf
} | [
"func",
"(",
"connection",
"*",
"Connection",
")",
"getInjectBuf",
"(",
"reply",
"bool",
")",
"InjectBuf",
"{",
"if",
"reply",
"{",
"return",
"connection",
".",
"ReplyBuf",
"\n",
"}",
"\n",
"return",
"connection",
".",
"OrigBuf",
"\n",
"}"
] | // getInjectBuf return the pointer to the inject buffer slice header for the indicated direction | [
"getInjectBuf",
"return",
"the",
"pointer",
"to",
"the",
"inject",
"buffer",
"slice",
"header",
"for",
"the",
"indicated",
"direction"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/proxylib/connection.go#L181-L186 |
163,429 | cilium/cilium | proxylib/proxylib/connection.go | Inject | func (connection *Connection) Inject(reply bool, data []byte) int {
buf := connection.getInjectBuf(reply)
// append data to C-provided buffer
offset := len(*buf)
n := copy((*buf)[offset:cap(*buf)], data)
*buf = (*buf)[:offset+n] // update the buffer length
log.Debugf("proxylib: Injected %d bytes: %s (given: %s)", n, string((*buf)[offset:offset+n]), string(data))
// return the number of bytes injected. This may be less than the length of `data` is
// the buffer becomes full.
// Parser may opt dropping the connection via parser error in this case!
return n
} | go | func (connection *Connection) Inject(reply bool, data []byte) int {
buf := connection.getInjectBuf(reply)
// append data to C-provided buffer
offset := len(*buf)
n := copy((*buf)[offset:cap(*buf)], data)
*buf = (*buf)[:offset+n] // update the buffer length
log.Debugf("proxylib: Injected %d bytes: %s (given: %s)", n, string((*buf)[offset:offset+n]), string(data))
// return the number of bytes injected. This may be less than the length of `data` is
// the buffer becomes full.
// Parser may opt dropping the connection via parser error in this case!
return n
} | [
"func",
"(",
"connection",
"*",
"Connection",
")",
"Inject",
"(",
"reply",
"bool",
",",
"data",
"[",
"]",
"byte",
")",
"int",
"{",
"buf",
":=",
"connection",
".",
"getInjectBuf",
"(",
"reply",
")",
"\n",
"// append data to C-provided buffer",
"offset",
":=",
"len",
"(",
"*",
"buf",
")",
"\n",
"n",
":=",
"copy",
"(",
"(",
"*",
"buf",
")",
"[",
"offset",
":",
"cap",
"(",
"*",
"buf",
")",
"]",
",",
"data",
")",
"\n",
"*",
"buf",
"=",
"(",
"*",
"buf",
")",
"[",
":",
"offset",
"+",
"n",
"]",
"// update the buffer length",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"n",
",",
"string",
"(",
"(",
"*",
"buf",
")",
"[",
"offset",
":",
"offset",
"+",
"n",
"]",
")",
",",
"string",
"(",
"data",
")",
")",
"\n\n",
"// return the number of bytes injected. This may be less than the length of `data` is",
"// the buffer becomes full.",
"// Parser may opt dropping the connection via parser error in this case!",
"return",
"n",
"\n",
"}"
] | // inject buffers data to be injected into the connection at the point of INJECT | [
"inject",
"buffers",
"data",
"to",
"be",
"injected",
"into",
"the",
"connection",
"at",
"the",
"point",
"of",
"INJECT"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/proxylib/connection.go#L189-L202 |
163,430 | cilium/cilium | proxylib/proxylib/connection.go | IsInjectBufFull | func (connection *Connection) IsInjectBufFull(reply bool) bool {
buf := connection.getInjectBuf(reply)
return len(*buf) == cap(*buf)
} | go | func (connection *Connection) IsInjectBufFull(reply bool) bool {
buf := connection.getInjectBuf(reply)
return len(*buf) == cap(*buf)
} | [
"func",
"(",
"connection",
"*",
"Connection",
")",
"IsInjectBufFull",
"(",
"reply",
"bool",
")",
"bool",
"{",
"buf",
":=",
"connection",
".",
"getInjectBuf",
"(",
"reply",
")",
"\n",
"return",
"len",
"(",
"*",
"buf",
")",
"==",
"cap",
"(",
"*",
"buf",
")",
"\n",
"}"
] | // isInjectBufFull return true if the inject buffer for the indicated direction is full | [
"isInjectBufFull",
"return",
"true",
"if",
"the",
"inject",
"buffer",
"for",
"the",
"indicated",
"direction",
"is",
"full"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/proxylib/connection.go#L205-L208 |
163,431 | cilium/cilium | api/v1/models/endpoint_policy.go | Validate | func (m *EndpointPolicy) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCidrPolicy(formats); err != nil {
res = append(res, err)
}
if err := m.validateL4(formats); err != nil {
res = append(res, err)
}
if err := m.validatePolicyEnabled(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *EndpointPolicy) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCidrPolicy(formats); err != nil {
res = append(res, err)
}
if err := m.validateL4(formats); err != nil {
res = append(res, err)
}
if err := m.validatePolicyEnabled(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"EndpointPolicy",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCidrPolicy",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateL4",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validatePolicyEnabled",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this endpoint policy | [
"Validate",
"validates",
"this",
"endpoint",
"policy"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/endpoint_policy.go#L47-L66 |
163,432 | cilium/cilium | pkg/node/manager/manager.go | NewManager | func NewManager(name string, datapath datapath.NodeHandler) (*Manager, error) {
m := &Manager{
name: name,
nodes: map[node.Identity]*nodeEntry{},
datapath: datapath,
closeChan: make(chan struct{}),
}
m.metricEventsReceived = prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_events_received_total",
Help: "Number of node events received",
}, []string{"eventType", "source"})
m.metricNumNodes = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_num",
Help: "Number of nodes managed",
})
m.metricDatapathValidations = prometheus.NewCounter(prometheus.CounterOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_datapath_validations_total",
Help: "Number of validation calls to implement the datapath implemention of a node",
})
err := metrics.RegisterList([]prometheus.Collector{m.metricDatapathValidations, m.metricEventsReceived, m.metricNumNodes})
if err != nil {
return nil, err
}
go m.backgroundSync()
return m, nil
} | go | func NewManager(name string, datapath datapath.NodeHandler) (*Manager, error) {
m := &Manager{
name: name,
nodes: map[node.Identity]*nodeEntry{},
datapath: datapath,
closeChan: make(chan struct{}),
}
m.metricEventsReceived = prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_events_received_total",
Help: "Number of node events received",
}, []string{"eventType", "source"})
m.metricNumNodes = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_num",
Help: "Number of nodes managed",
})
m.metricDatapathValidations = prometheus.NewCounter(prometheus.CounterOpts{
Namespace: metrics.Namespace,
Subsystem: "nodes",
Name: name + "_datapath_validations_total",
Help: "Number of validation calls to implement the datapath implemention of a node",
})
err := metrics.RegisterList([]prometheus.Collector{m.metricDatapathValidations, m.metricEventsReceived, m.metricNumNodes})
if err != nil {
return nil, err
}
go m.backgroundSync()
return m, nil
} | [
"func",
"NewManager",
"(",
"name",
"string",
",",
"datapath",
"datapath",
".",
"NodeHandler",
")",
"(",
"*",
"Manager",
",",
"error",
")",
"{",
"m",
":=",
"&",
"Manager",
"{",
"name",
":",
"name",
",",
"nodes",
":",
"map",
"[",
"node",
".",
"Identity",
"]",
"*",
"nodeEntry",
"{",
"}",
",",
"datapath",
":",
"datapath",
",",
"closeChan",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n\n",
"m",
".",
"metricEventsReceived",
"=",
"prometheus",
".",
"NewCounterVec",
"(",
"prometheus",
".",
"CounterOpts",
"{",
"Namespace",
":",
"metrics",
".",
"Namespace",
",",
"Subsystem",
":",
"\"",
"\"",
",",
"Name",
":",
"name",
"+",
"\"",
"\"",
",",
"Help",
":",
"\"",
"\"",
",",
"}",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n\n",
"m",
".",
"metricNumNodes",
"=",
"prometheus",
".",
"NewGauge",
"(",
"prometheus",
".",
"GaugeOpts",
"{",
"Namespace",
":",
"metrics",
".",
"Namespace",
",",
"Subsystem",
":",
"\"",
"\"",
",",
"Name",
":",
"name",
"+",
"\"",
"\"",
",",
"Help",
":",
"\"",
"\"",
",",
"}",
")",
"\n\n",
"m",
".",
"metricDatapathValidations",
"=",
"prometheus",
".",
"NewCounter",
"(",
"prometheus",
".",
"CounterOpts",
"{",
"Namespace",
":",
"metrics",
".",
"Namespace",
",",
"Subsystem",
":",
"\"",
"\"",
",",
"Name",
":",
"name",
"+",
"\"",
"\"",
",",
"Help",
":",
"\"",
"\"",
",",
"}",
")",
"\n\n",
"err",
":=",
"metrics",
".",
"RegisterList",
"(",
"[",
"]",
"prometheus",
".",
"Collector",
"{",
"m",
".",
"metricDatapathValidations",
",",
"m",
".",
"metricEventsReceived",
",",
"m",
".",
"metricNumNodes",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"go",
"m",
".",
"backgroundSync",
"(",
")",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // NewManager returns a new node manager | [
"NewManager",
"returns",
"a",
"new",
"node",
"manager"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L94-L131 |
163,433 | cilium/cilium | pkg/node/manager/manager.go | Close | func (m *Manager) Close() {
m.mutex.Lock()
defer m.mutex.Unlock()
close(m.closeChan)
metrics.Unregister(m.metricNumNodes)
metrics.Unregister(m.metricEventsReceived)
metrics.Unregister(m.metricDatapathValidations)
// delete all nodes to clean up the datapath for each node
for _, n := range m.nodes {
n.mutex.Lock()
m.datapath.NodeDelete(n.node)
n.mutex.Unlock()
}
} | go | func (m *Manager) Close() {
m.mutex.Lock()
defer m.mutex.Unlock()
close(m.closeChan)
metrics.Unregister(m.metricNumNodes)
metrics.Unregister(m.metricEventsReceived)
metrics.Unregister(m.metricDatapathValidations)
// delete all nodes to clean up the datapath for each node
for _, n := range m.nodes {
n.mutex.Lock()
m.datapath.NodeDelete(n.node)
n.mutex.Unlock()
}
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"Close",
"(",
")",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"close",
"(",
"m",
".",
"closeChan",
")",
"\n\n",
"metrics",
".",
"Unregister",
"(",
"m",
".",
"metricNumNodes",
")",
"\n",
"metrics",
".",
"Unregister",
"(",
"m",
".",
"metricEventsReceived",
")",
"\n",
"metrics",
".",
"Unregister",
"(",
"m",
".",
"metricDatapathValidations",
")",
"\n\n",
"// delete all nodes to clean up the datapath for each node",
"for",
"_",
",",
"n",
":=",
"range",
"m",
".",
"nodes",
"{",
"n",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"m",
".",
"datapath",
".",
"NodeDelete",
"(",
"n",
".",
"node",
")",
"\n",
"n",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Close shuts down a node manager | [
"Close",
"shuts",
"down",
"a",
"node",
"manager"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L134-L150 |
163,434 | cilium/cilium | pkg/node/manager/manager.go | overwriteAllowed | func overwriteAllowed(oldSource, newSource node.Source) bool {
switch newSource {
// the local node always takes precedence
case node.FromLocalNode:
return true
// agent local updates can overwrite everything except for the local
// node
case node.FromAgentLocal:
return oldSource != node.FromLocalNode
// kvstore updates can overwrite everything except agent local updates and local node
case node.FromKVStore:
return oldSource != node.FromAgentLocal && oldSource != node.FromLocalNode
// kubernetes updates can only overwrite kubernetes nodes
case node.FromKubernetes:
return oldSource != node.FromAgentLocal && oldSource != node.FromLocalNode && oldSource != node.FromKVStore
default:
return false
}
} | go | func overwriteAllowed(oldSource, newSource node.Source) bool {
switch newSource {
// the local node always takes precedence
case node.FromLocalNode:
return true
// agent local updates can overwrite everything except for the local
// node
case node.FromAgentLocal:
return oldSource != node.FromLocalNode
// kvstore updates can overwrite everything except agent local updates and local node
case node.FromKVStore:
return oldSource != node.FromAgentLocal && oldSource != node.FromLocalNode
// kubernetes updates can only overwrite kubernetes nodes
case node.FromKubernetes:
return oldSource != node.FromAgentLocal && oldSource != node.FromLocalNode && oldSource != node.FromKVStore
default:
return false
}
} | [
"func",
"overwriteAllowed",
"(",
"oldSource",
",",
"newSource",
"node",
".",
"Source",
")",
"bool",
"{",
"switch",
"newSource",
"{",
"// the local node always takes precedence",
"case",
"node",
".",
"FromLocalNode",
":",
"return",
"true",
"\n\n",
"// agent local updates can overwrite everything except for the local",
"// node",
"case",
"node",
".",
"FromAgentLocal",
":",
"return",
"oldSource",
"!=",
"node",
".",
"FromLocalNode",
"\n\n",
"// kvstore updates can overwrite everything except agent local updates and local node",
"case",
"node",
".",
"FromKVStore",
":",
"return",
"oldSource",
"!=",
"node",
".",
"FromAgentLocal",
"&&",
"oldSource",
"!=",
"node",
".",
"FromLocalNode",
"\n\n",
"// kubernetes updates can only overwrite kubernetes nodes",
"case",
"node",
".",
"FromKubernetes",
":",
"return",
"oldSource",
"!=",
"node",
".",
"FromAgentLocal",
"&&",
"oldSource",
"!=",
"node",
".",
"FromLocalNode",
"&&",
"oldSource",
"!=",
"node",
".",
"FromKVStore",
"\n\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // overwriteAllowed returns true if an update from newSource can overwrite a node owned by oldSource. | [
"overwriteAllowed",
"returns",
"true",
"if",
"an",
"update",
"from",
"newSource",
"can",
"overwrite",
"a",
"node",
"owned",
"by",
"oldSource",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L231-L253 |
163,435 | cilium/cilium | pkg/node/manager/manager.go | NodeSoftUpdated | func (m *Manager) NodeSoftUpdated(n node.Node) {
log.Debugf("Received soft node update event from %s: %#v", n.Source, n)
m.nodeUpdated(n, false)
} | go | func (m *Manager) NodeSoftUpdated(n node.Node) {
log.Debugf("Received soft node update event from %s: %#v", n.Source, n)
m.nodeUpdated(n, false)
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"NodeSoftUpdated",
"(",
"n",
"node",
".",
"Node",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"n",
".",
"Source",
",",
"n",
")",
"\n",
"m",
".",
"nodeUpdated",
"(",
"n",
",",
"false",
")",
"\n",
"}"
] | // NodeSoftUpdated is called after the information of a node has be upated but
// unlike a NodeUpdated does not require the datapath to be updated. | [
"NodeSoftUpdated",
"is",
"called",
"after",
"the",
"information",
"of",
"a",
"node",
"has",
"be",
"upated",
"but",
"unlike",
"a",
"NodeUpdated",
"does",
"not",
"require",
"the",
"datapath",
"to",
"be",
"updated",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L257-L260 |
163,436 | cilium/cilium | pkg/node/manager/manager.go | GetNodes | func (m *Manager) GetNodes() map[node.Identity]node.Node {
m.mutex.RLock()
defer m.mutex.RUnlock()
nodes := make(map[node.Identity]node.Node)
for nodeIdentity, entry := range m.nodes {
entry.mutex.Lock()
nodes[nodeIdentity] = entry.node
entry.mutex.Unlock()
}
return nodes
} | go | func (m *Manager) GetNodes() map[node.Identity]node.Node {
m.mutex.RLock()
defer m.mutex.RUnlock()
nodes := make(map[node.Identity]node.Node)
for nodeIdentity, entry := range m.nodes {
entry.mutex.Lock()
nodes[nodeIdentity] = entry.node
entry.mutex.Unlock()
}
return nodes
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"GetNodes",
"(",
")",
"map",
"[",
"node",
".",
"Identity",
"]",
"node",
".",
"Node",
"{",
"m",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"nodes",
":=",
"make",
"(",
"map",
"[",
"node",
".",
"Identity",
"]",
"node",
".",
"Node",
")",
"\n",
"for",
"nodeIdentity",
",",
"entry",
":=",
"range",
"m",
".",
"nodes",
"{",
"entry",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"nodes",
"[",
"nodeIdentity",
"]",
"=",
"entry",
".",
"node",
"\n",
"entry",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nodes",
"\n",
"}"
] | // GetNodes returns a copy of all of the nodes as a map from Identity to Node. | [
"GetNodes",
"returns",
"a",
"copy",
"of",
"all",
"of",
"the",
"nodes",
"as",
"a",
"map",
"from",
"Identity",
"to",
"Node",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L342-L354 |
163,437 | cilium/cilium | pkg/node/manager/manager.go | DeleteAllNodes | func (m *Manager) DeleteAllNodes() {
m.mutex.Lock()
for _, entry := range m.nodes {
entry.mutex.Lock()
m.datapath.NodeDelete(entry.node)
entry.mutex.Unlock()
}
m.nodes = map[node.Identity]*nodeEntry{}
m.mutex.Unlock()
} | go | func (m *Manager) DeleteAllNodes() {
m.mutex.Lock()
for _, entry := range m.nodes {
entry.mutex.Lock()
m.datapath.NodeDelete(entry.node)
entry.mutex.Unlock()
}
m.nodes = map[node.Identity]*nodeEntry{}
m.mutex.Unlock()
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"DeleteAllNodes",
"(",
")",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"entry",
":=",
"range",
"m",
".",
"nodes",
"{",
"entry",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"m",
".",
"datapath",
".",
"NodeDelete",
"(",
"entry",
".",
"node",
")",
"\n",
"entry",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"m",
".",
"nodes",
"=",
"map",
"[",
"node",
".",
"Identity",
"]",
"*",
"nodeEntry",
"{",
"}",
"\n",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // DeleteAllNodes deletes all nodes from the node maanger. | [
"DeleteAllNodes",
"deletes",
"all",
"nodes",
"from",
"the",
"node",
"maanger",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/manager/manager.go#L357-L366 |
163,438 | cilium/cilium | pkg/k8s/rule_translate.go | Translate | func (k RuleTranslator) Translate(r *api.Rule, result *policy.TranslationResult) error {
for egressIndex := range r.Egress {
err := k.TranslateEgress(&r.Egress[egressIndex], result)
if err != nil {
return err
}
}
return nil
} | go | func (k RuleTranslator) Translate(r *api.Rule, result *policy.TranslationResult) error {
for egressIndex := range r.Egress {
err := k.TranslateEgress(&r.Egress[egressIndex], result)
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"k",
"RuleTranslator",
")",
"Translate",
"(",
"r",
"*",
"api",
".",
"Rule",
",",
"result",
"*",
"policy",
".",
"TranslationResult",
")",
"error",
"{",
"for",
"egressIndex",
":=",
"range",
"r",
".",
"Egress",
"{",
"err",
":=",
"k",
".",
"TranslateEgress",
"(",
"&",
"r",
".",
"Egress",
"[",
"egressIndex",
"]",
",",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Translate calls TranslateEgress on all r.Egress rules | [
"Translate",
"calls",
"TranslateEgress",
"on",
"all",
"r",
".",
"Egress",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/rule_translate.go#L42-L50 |
163,439 | cilium/cilium | pkg/k8s/rule_translate.go | generateToCidrFromEndpoint | func generateToCidrFromEndpoint(
egress *api.EgressRule,
endpoint Endpoints,
impl ipcache.Implementation) error {
// Non-nil implementation here implies that this translation is
// occurring after policy import. This means that the CIDRs were not
// known at that time, so the IPCache hasn't been informed about them.
// In this case, it's the job of this Translator to notify the IPCache.
if impl != nil {
prefixes, err := endpoint.CIDRPrefixes()
if err != nil {
return err
}
if err := ipcache.AllocateCIDRs(impl, prefixes); err != nil {
return err
}
}
// This will generate one-address CIDRs consisting of endpoint backend ip
mask := net.CIDRMask(128, 128)
for ip := range endpoint.Backends {
epIP := net.ParseIP(ip)
if epIP == nil {
return fmt.Errorf("Unable to parse ip: %s", ip)
}
found := false
for _, c := range egress.ToCIDRSet {
_, cidr, err := net.ParseCIDR(string(c.Cidr))
if err != nil {
return err
}
if cidr.Contains(epIP) {
found = true
break
}
}
if !found {
cidr := net.IPNet{IP: epIP.Mask(mask), Mask: mask}
egress.ToCIDRSet = append(egress.ToCIDRSet, api.CIDRRule{
Cidr: api.CIDR(cidr.String()),
Generated: true,
})
}
}
return nil
} | go | func generateToCidrFromEndpoint(
egress *api.EgressRule,
endpoint Endpoints,
impl ipcache.Implementation) error {
// Non-nil implementation here implies that this translation is
// occurring after policy import. This means that the CIDRs were not
// known at that time, so the IPCache hasn't been informed about them.
// In this case, it's the job of this Translator to notify the IPCache.
if impl != nil {
prefixes, err := endpoint.CIDRPrefixes()
if err != nil {
return err
}
if err := ipcache.AllocateCIDRs(impl, prefixes); err != nil {
return err
}
}
// This will generate one-address CIDRs consisting of endpoint backend ip
mask := net.CIDRMask(128, 128)
for ip := range endpoint.Backends {
epIP := net.ParseIP(ip)
if epIP == nil {
return fmt.Errorf("Unable to parse ip: %s", ip)
}
found := false
for _, c := range egress.ToCIDRSet {
_, cidr, err := net.ParseCIDR(string(c.Cidr))
if err != nil {
return err
}
if cidr.Contains(epIP) {
found = true
break
}
}
if !found {
cidr := net.IPNet{IP: epIP.Mask(mask), Mask: mask}
egress.ToCIDRSet = append(egress.ToCIDRSet, api.CIDRRule{
Cidr: api.CIDR(cidr.String()),
Generated: true,
})
}
}
return nil
} | [
"func",
"generateToCidrFromEndpoint",
"(",
"egress",
"*",
"api",
".",
"EgressRule",
",",
"endpoint",
"Endpoints",
",",
"impl",
"ipcache",
".",
"Implementation",
")",
"error",
"{",
"// Non-nil implementation here implies that this translation is",
"// occurring after policy import. This means that the CIDRs were not",
"// known at that time, so the IPCache hasn't been informed about them.",
"// In this case, it's the job of this Translator to notify the IPCache.",
"if",
"impl",
"!=",
"nil",
"{",
"prefixes",
",",
"err",
":=",
"endpoint",
".",
"CIDRPrefixes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"ipcache",
".",
"AllocateCIDRs",
"(",
"impl",
",",
"prefixes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// This will generate one-address CIDRs consisting of endpoint backend ip",
"mask",
":=",
"net",
".",
"CIDRMask",
"(",
"128",
",",
"128",
")",
"\n",
"for",
"ip",
":=",
"range",
"endpoint",
".",
"Backends",
"{",
"epIP",
":=",
"net",
".",
"ParseIP",
"(",
"ip",
")",
"\n",
"if",
"epIP",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ip",
")",
"\n",
"}",
"\n\n",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"egress",
".",
"ToCIDRSet",
"{",
"_",
",",
"cidr",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"string",
"(",
"c",
".",
"Cidr",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"cidr",
".",
"Contains",
"(",
"epIP",
")",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"cidr",
":=",
"net",
".",
"IPNet",
"{",
"IP",
":",
"epIP",
".",
"Mask",
"(",
"mask",
")",
",",
"Mask",
":",
"mask",
"}",
"\n",
"egress",
".",
"ToCIDRSet",
"=",
"append",
"(",
"egress",
".",
"ToCIDRSet",
",",
"api",
".",
"CIDRRule",
"{",
"Cidr",
":",
"api",
".",
"CIDR",
"(",
"cidr",
".",
"String",
"(",
")",
")",
",",
"Generated",
":",
"true",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // generateToCidrFromEndpoint takes an egress rule and populates it with
// ToCIDR rules based on provided endpoint object | [
"generateToCidrFromEndpoint",
"takes",
"an",
"egress",
"rule",
"and",
"populates",
"it",
"with",
"ToCIDR",
"rules",
"based",
"on",
"provided",
"endpoint",
"object"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/rule_translate.go#L116-L163 |
163,440 | cilium/cilium | pkg/k8s/rule_translate.go | PreprocessRules | func PreprocessRules(r api.Rules, cache *ServiceCache) error {
// Headless services are translated prior to policy import, so the
// policy will contain all of the CIDRs and can handle ipcache
// interactions when the policy is imported. Ignore the IPCache
// interaction here and just set the implementation to nil.
ipcache := ipcache.Implementation(nil)
cache.mutex.Lock()
defer cache.mutex.Unlock()
for _, rule := range r {
for ns, ep := range cache.endpoints {
svc, ok := cache.services[ns]
if ok && svc.IsExternal() {
t := NewK8sTranslator(ns, *ep, false, svc.Labels, ipcache)
err := t.Translate(rule, &policy.TranslationResult{})
if err != nil {
return err
}
}
}
}
return nil
} | go | func PreprocessRules(r api.Rules, cache *ServiceCache) error {
// Headless services are translated prior to policy import, so the
// policy will contain all of the CIDRs and can handle ipcache
// interactions when the policy is imported. Ignore the IPCache
// interaction here and just set the implementation to nil.
ipcache := ipcache.Implementation(nil)
cache.mutex.Lock()
defer cache.mutex.Unlock()
for _, rule := range r {
for ns, ep := range cache.endpoints {
svc, ok := cache.services[ns]
if ok && svc.IsExternal() {
t := NewK8sTranslator(ns, *ep, false, svc.Labels, ipcache)
err := t.Translate(rule, &policy.TranslationResult{})
if err != nil {
return err
}
}
}
}
return nil
} | [
"func",
"PreprocessRules",
"(",
"r",
"api",
".",
"Rules",
",",
"cache",
"*",
"ServiceCache",
")",
"error",
"{",
"// Headless services are translated prior to policy import, so the",
"// policy will contain all of the CIDRs and can handle ipcache",
"// interactions when the policy is imported. Ignore the IPCache",
"// interaction here and just set the implementation to nil.",
"ipcache",
":=",
"ipcache",
".",
"Implementation",
"(",
"nil",
")",
"\n\n",
"cache",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cache",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"r",
"{",
"for",
"ns",
",",
"ep",
":=",
"range",
"cache",
".",
"endpoints",
"{",
"svc",
",",
"ok",
":=",
"cache",
".",
"services",
"[",
"ns",
"]",
"\n",
"if",
"ok",
"&&",
"svc",
".",
"IsExternal",
"(",
")",
"{",
"t",
":=",
"NewK8sTranslator",
"(",
"ns",
",",
"*",
"ep",
",",
"false",
",",
"svc",
".",
"Labels",
",",
"ipcache",
")",
"\n",
"err",
":=",
"t",
".",
"Translate",
"(",
"rule",
",",
"&",
"policy",
".",
"TranslationResult",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // PreprocessRules translates rules that apply to headless services | [
"PreprocessRules",
"translates",
"rules",
"that",
"apply",
"to",
"headless",
"services"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/rule_translate.go#L212-L236 |
163,441 | cilium/cilium | pkg/k8s/rule_translate.go | NewK8sTranslator | func NewK8sTranslator(
serviceInfo ServiceID,
endpoint Endpoints,
revert bool,
labels map[string]string,
ipcache ipcache.Implementation) RuleTranslator {
return RuleTranslator{serviceInfo, endpoint, labels, revert, ipcache}
} | go | func NewK8sTranslator(
serviceInfo ServiceID,
endpoint Endpoints,
revert bool,
labels map[string]string,
ipcache ipcache.Implementation) RuleTranslator {
return RuleTranslator{serviceInfo, endpoint, labels, revert, ipcache}
} | [
"func",
"NewK8sTranslator",
"(",
"serviceInfo",
"ServiceID",
",",
"endpoint",
"Endpoints",
",",
"revert",
"bool",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"ipcache",
"ipcache",
".",
"Implementation",
")",
"RuleTranslator",
"{",
"return",
"RuleTranslator",
"{",
"serviceInfo",
",",
"endpoint",
",",
"labels",
",",
"revert",
",",
"ipcache",
"}",
"\n",
"}"
] | // NewK8sTranslator returns RuleTranslator | [
"NewK8sTranslator",
"returns",
"RuleTranslator"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/rule_translate.go#L239-L247 |
163,442 | cilium/cilium | pkg/safetime/safetime.go | TimeSinceSafe | func TimeSinceSafe(t time.Time, logger *log.Entry) (time.Duration, bool) {
n := time.Now()
d := n.Sub(t)
if d < 0 {
logger = logger.WithFields(log.Fields{
logfields.StartTime: t,
logfields.EndTime: n,
logfields.Duration: d,
})
_, file, line, ok := runtime.Caller(1)
if ok {
logger = logger.WithFields(log.Fields{
logfields.Path: file,
logfields.Line: line,
})
}
logger.Warn("BUG: negative duration")
return time.Duration(0), false
}
return d, true
} | go | func TimeSinceSafe(t time.Time, logger *log.Entry) (time.Duration, bool) {
n := time.Now()
d := n.Sub(t)
if d < 0 {
logger = logger.WithFields(log.Fields{
logfields.StartTime: t,
logfields.EndTime: n,
logfields.Duration: d,
})
_, file, line, ok := runtime.Caller(1)
if ok {
logger = logger.WithFields(log.Fields{
logfields.Path: file,
logfields.Line: line,
})
}
logger.Warn("BUG: negative duration")
return time.Duration(0), false
}
return d, true
} | [
"func",
"TimeSinceSafe",
"(",
"t",
"time",
".",
"Time",
",",
"logger",
"*",
"log",
".",
"Entry",
")",
"(",
"time",
".",
"Duration",
",",
"bool",
")",
"{",
"n",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"d",
":=",
"n",
".",
"Sub",
"(",
"t",
")",
"\n\n",
"if",
"d",
"<",
"0",
"{",
"logger",
"=",
"logger",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"logfields",
".",
"StartTime",
":",
"t",
",",
"logfields",
".",
"EndTime",
":",
"n",
",",
"logfields",
".",
"Duration",
":",
"d",
",",
"}",
")",
"\n",
"_",
",",
"file",
",",
"line",
",",
"ok",
":=",
"runtime",
".",
"Caller",
"(",
"1",
")",
"\n",
"if",
"ok",
"{",
"logger",
"=",
"logger",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"logfields",
".",
"Path",
":",
"file",
",",
"logfields",
".",
"Line",
":",
"line",
",",
"}",
")",
"\n",
"}",
"\n",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"time",
".",
"Duration",
"(",
"0",
")",
",",
"false",
"\n",
"}",
"\n\n",
"return",
"d",
",",
"true",
"\n",
"}"
] | // TimeSinceSafe returns the duration since t. If the duration is negative,
// returns false to indicate the fact.
//
// Used to workaround a malfunctioning monotonic clock. | [
"TimeSinceSafe",
"returns",
"the",
"duration",
"since",
"t",
".",
"If",
"the",
"duration",
"is",
"negative",
"returns",
"false",
"to",
"indicate",
"the",
"fact",
".",
"Used",
"to",
"workaround",
"a",
"malfunctioning",
"monotonic",
"clock",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/safetime/safetime.go#L30-L53 |
163,443 | cilium/cilium | api/v1/models/request_response_statistics.go | Validate | func (m *RequestResponseStatistics) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateRequests(formats); err != nil {
res = append(res, err)
}
if err := m.validateResponses(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *RequestResponseStatistics) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateRequests(formats); err != nil {
res = append(res, err)
}
if err := m.validateResponses(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"RequestResponseStatistics",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateRequests",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateResponses",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this request response statistics | [
"Validate",
"validates",
"this",
"request",
"response",
"statistics"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/request_response_statistics.go#L28-L43 |
163,444 | cilium/cilium | api/v1/models/port.go | Validate | func (m *Port) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateProtocol(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *Port) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateProtocol(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"Port",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateProtocol",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this port | [
"Validate",
"validates",
"this",
"port"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/port.go#L31-L42 |
163,445 | cilium/cilium | api/v1/models/controller_statuses.go | Validate | func (m ControllerStatuses) Validate(formats strfmt.Registry) error {
var res []error
for i := 0; i < len(m); i++ {
if swag.IsZero(m[i]) { // not required
continue
}
if m[i] != nil {
if err := m[i].Validate(formats); err != nil {
if ve, ok := err.(*errors.Validation); ok {
return ve.ValidateName(strconv.Itoa(i))
}
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m ControllerStatuses) Validate(formats strfmt.Registry) error {
var res []error
for i := 0; i < len(m); i++ {
if swag.IsZero(m[i]) { // not required
continue
}
if m[i] != nil {
if err := m[i].Validate(formats); err != nil {
if ve, ok := err.(*errors.Validation); ok {
return ve.ValidateName(strconv.Itoa(i))
}
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"ControllerStatuses",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"m",
")",
";",
"i",
"++",
"{",
"if",
"swag",
".",
"IsZero",
"(",
"m",
"[",
"i",
"]",
")",
"{",
"// not required",
"continue",
"\n",
"}",
"\n\n",
"if",
"m",
"[",
"i",
"]",
"!=",
"nil",
"{",
"if",
"err",
":=",
"m",
"[",
"i",
"]",
".",
"Validate",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"ve",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"errors",
".",
"Validation",
")",
";",
"ok",
"{",
"return",
"ve",
".",
"ValidateName",
"(",
"strconv",
".",
"Itoa",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this controller statuses | [
"Validate",
"validates",
"this",
"controller",
"statuses"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/controller_statuses.go#L22-L45 |
163,446 | cilium/cilium | daemon/daemon_main.go | RestoreExecPermissions | func RestoreExecPermissions(searchDir string, patterns ...string) error {
fileList := []string{}
err := filepath.Walk(searchDir, func(path string, f os.FileInfo, err error) error {
for _, pattern := range patterns {
if regexp.MustCompile(pattern).MatchString(f.Name()) {
fileList = append(fileList, path)
break
}
}
return nil
})
for _, fileToChange := range fileList {
// Changing files permissions to -rwx:r--:---, we are only
// adding executable permission to the owner and keeping the
// same permissions stored by go-bindata.
if err := os.Chmod(fileToChange, os.FileMode(0740)); err != nil {
return err
}
}
return err
} | go | func RestoreExecPermissions(searchDir string, patterns ...string) error {
fileList := []string{}
err := filepath.Walk(searchDir, func(path string, f os.FileInfo, err error) error {
for _, pattern := range patterns {
if regexp.MustCompile(pattern).MatchString(f.Name()) {
fileList = append(fileList, path)
break
}
}
return nil
})
for _, fileToChange := range fileList {
// Changing files permissions to -rwx:r--:---, we are only
// adding executable permission to the owner and keeping the
// same permissions stored by go-bindata.
if err := os.Chmod(fileToChange, os.FileMode(0740)); err != nil {
return err
}
}
return err
} | [
"func",
"RestoreExecPermissions",
"(",
"searchDir",
"string",
",",
"patterns",
"...",
"string",
")",
"error",
"{",
"fileList",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"err",
":=",
"filepath",
".",
"Walk",
"(",
"searchDir",
",",
"func",
"(",
"path",
"string",
",",
"f",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"for",
"_",
",",
"pattern",
":=",
"range",
"patterns",
"{",
"if",
"regexp",
".",
"MustCompile",
"(",
"pattern",
")",
".",
"MatchString",
"(",
"f",
".",
"Name",
"(",
")",
")",
"{",
"fileList",
"=",
"append",
"(",
"fileList",
",",
"path",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"for",
"_",
",",
"fileToChange",
":=",
"range",
"fileList",
"{",
"// Changing files permissions to -rwx:r--:---, we are only",
"// adding executable permission to the owner and keeping the",
"// same permissions stored by go-bindata.",
"if",
"err",
":=",
"os",
".",
"Chmod",
"(",
"fileToChange",
",",
"os",
".",
"FileMode",
"(",
"0740",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // RestoreExecPermissions restores file permissions to 0740 of all files inside
// `searchDir` with the given regex `patterns`. | [
"RestoreExecPermissions",
"restores",
"file",
"permissions",
"to",
"0740",
"of",
"all",
"files",
"inside",
"searchDir",
"with",
"the",
"given",
"regex",
"patterns",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/daemon/daemon_main.go#L736-L756 |
163,447 | cilium/cilium | daemon/daemon_main.go | waitForHostDeviceWhenReady | func waitForHostDeviceWhenReady(ifaceName string) error {
for i := 0; ; i++ {
if i%10 == 0 {
log.WithField(logfields.Interface, ifaceName).
Info("Waiting for the underlying interface to be initialized with containers")
}
_, err := netlink.LinkByName(ifaceName)
if err == nil {
log.WithField(logfields.Interface, ifaceName).
Info("Underlying interface initialized with containers!")
break
}
select {
case <-cleanUPSig:
return errors.New("clean up signal triggered")
default:
time.Sleep(time.Second)
}
}
return nil
} | go | func waitForHostDeviceWhenReady(ifaceName string) error {
for i := 0; ; i++ {
if i%10 == 0 {
log.WithField(logfields.Interface, ifaceName).
Info("Waiting for the underlying interface to be initialized with containers")
}
_, err := netlink.LinkByName(ifaceName)
if err == nil {
log.WithField(logfields.Interface, ifaceName).
Info("Underlying interface initialized with containers!")
break
}
select {
case <-cleanUPSig:
return errors.New("clean up signal triggered")
default:
time.Sleep(time.Second)
}
}
return nil
} | [
"func",
"waitForHostDeviceWhenReady",
"(",
"ifaceName",
"string",
")",
"error",
"{",
"for",
"i",
":=",
"0",
";",
";",
"i",
"++",
"{",
"if",
"i",
"%",
"10",
"==",
"0",
"{",
"log",
".",
"WithField",
"(",
"logfields",
".",
"Interface",
",",
"ifaceName",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"netlink",
".",
"LinkByName",
"(",
"ifaceName",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"log",
".",
"WithField",
"(",
"logfields",
".",
"Interface",
",",
"ifaceName",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"break",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"cleanUPSig",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // waitForHostDeviceWhenReady waits the given ifaceName to be up and ready. If
// ifaceName is not found, then it will wait forever until the device is
// created. | [
"waitForHostDeviceWhenReady",
"waits",
"the",
"given",
"ifaceName",
"to",
"be",
"up",
"and",
"ready",
".",
"If",
"ifaceName",
"is",
"not",
"found",
"then",
"it",
"will",
"wait",
"forever",
"until",
"the",
"device",
"is",
"created",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/daemon/daemon_main.go#L1106-L1126 |
163,448 | cilium/cilium | proxylib/cassandra/cassandraparser.go | CassandraRuleParser | func CassandraRuleParser(rule *cilium.PortNetworkPolicyRule) []L7NetworkPolicyRule {
var rules []L7NetworkPolicyRule
l7Rules := rule.GetL7Rules()
if l7Rules == nil {
return rules
}
for _, l7Rule := range l7Rules.GetL7Rules() {
var cr CassandraRule
for k, v := range l7Rule.Rule {
switch k {
case "query_action":
cr.queryActionExact = v
case "query_table":
if v != "" {
cr.tableRegexCompiled = regexp.MustCompile(v)
}
default:
ParseError(fmt.Sprintf("Unsupported key: %s", k), rule)
}
}
if len(cr.queryActionExact) > 0 {
// ensure this is a valid query action
res := queryActionMap[cr.queryActionExact]
if res == invalidAction {
ParseError(fmt.Sprintf("Unable to parse L7 cassandra rule with invalid query_action: '%s'", cr.queryActionExact), rule)
} else if res == actionNoTable && cr.tableRegexCompiled != nil {
ParseError(fmt.Sprintf("query_action '%s' is not compatible with a query_table match", cr.queryActionExact), rule)
}
}
log.Debugf("Parsed CassandraRule pair: %v", cr)
rules = append(rules, &cr)
}
return rules
} | go | func CassandraRuleParser(rule *cilium.PortNetworkPolicyRule) []L7NetworkPolicyRule {
var rules []L7NetworkPolicyRule
l7Rules := rule.GetL7Rules()
if l7Rules == nil {
return rules
}
for _, l7Rule := range l7Rules.GetL7Rules() {
var cr CassandraRule
for k, v := range l7Rule.Rule {
switch k {
case "query_action":
cr.queryActionExact = v
case "query_table":
if v != "" {
cr.tableRegexCompiled = regexp.MustCompile(v)
}
default:
ParseError(fmt.Sprintf("Unsupported key: %s", k), rule)
}
}
if len(cr.queryActionExact) > 0 {
// ensure this is a valid query action
res := queryActionMap[cr.queryActionExact]
if res == invalidAction {
ParseError(fmt.Sprintf("Unable to parse L7 cassandra rule with invalid query_action: '%s'", cr.queryActionExact), rule)
} else if res == actionNoTable && cr.tableRegexCompiled != nil {
ParseError(fmt.Sprintf("query_action '%s' is not compatible with a query_table match", cr.queryActionExact), rule)
}
}
log.Debugf("Parsed CassandraRule pair: %v", cr)
rules = append(rules, &cr)
}
return rules
} | [
"func",
"CassandraRuleParser",
"(",
"rule",
"*",
"cilium",
".",
"PortNetworkPolicyRule",
")",
"[",
"]",
"L7NetworkPolicyRule",
"{",
"var",
"rules",
"[",
"]",
"L7NetworkPolicyRule",
"\n",
"l7Rules",
":=",
"rule",
".",
"GetL7Rules",
"(",
")",
"\n",
"if",
"l7Rules",
"==",
"nil",
"{",
"return",
"rules",
"\n",
"}",
"\n",
"for",
"_",
",",
"l7Rule",
":=",
"range",
"l7Rules",
".",
"GetL7Rules",
"(",
")",
"{",
"var",
"cr",
"CassandraRule",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"l7Rule",
".",
"Rule",
"{",
"switch",
"k",
"{",
"case",
"\"",
"\"",
":",
"cr",
".",
"queryActionExact",
"=",
"v",
"\n",
"case",
"\"",
"\"",
":",
"if",
"v",
"!=",
"\"",
"\"",
"{",
"cr",
".",
"tableRegexCompiled",
"=",
"regexp",
".",
"MustCompile",
"(",
"v",
")",
"\n",
"}",
"\n",
"default",
":",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
")",
",",
"rule",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"cr",
".",
"queryActionExact",
")",
">",
"0",
"{",
"// ensure this is a valid query action",
"res",
":=",
"queryActionMap",
"[",
"cr",
".",
"queryActionExact",
"]",
"\n",
"if",
"res",
"==",
"invalidAction",
"{",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cr",
".",
"queryActionExact",
")",
",",
"rule",
")",
"\n",
"}",
"else",
"if",
"res",
"==",
"actionNoTable",
"&&",
"cr",
".",
"tableRegexCompiled",
"!=",
"nil",
"{",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cr",
".",
"queryActionExact",
")",
",",
"rule",
")",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"cr",
")",
"\n",
"rules",
"=",
"append",
"(",
"rules",
",",
"&",
"cr",
")",
"\n",
"}",
"\n",
"return",
"rules",
"\n",
"}"
] | // CassandraRuleParser parses protobuf L7 rules to enforcement objects
// May panic | [
"CassandraRuleParser",
"parses",
"protobuf",
"L7",
"rules",
"to",
"enforcement",
"objects",
"May",
"panic"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/cassandra/cassandraparser.go#L108-L143 |
163,449 | cilium/cilium | proxylib/cassandra/cassandraparser.go | cassandraParseReply | func cassandraParseReply(p *CassandraParser, data []byte) {
direction := data[0] & 0x80 // top bit
if direction != 0x80 {
log.Errorf("Direction bit is 'request', but we are trying to parse a reply")
return
}
compressionFlag := data[1] & 0x01
if compressionFlag == 1 {
log.Errorf("Compression flag set, unable to parse reply beyond the header")
return
}
streamID := binary.BigEndian.Uint16(data[2:4])
log.Debugf("Reply with opcode %d and stream-id %d", data[4], streamID)
// if this is an opcode == RESULT message of type 'prepared', associate the prepared
// statement id with the full query string that was included in the
// associated PREPARE request. The stream-id in this reply allows us to
// find the associated prepare query string.
if data[4] == 0x08 {
resultKind := binary.BigEndian.Uint32(data[9:13])
log.Debugf("resultKind = %d", resultKind)
if resultKind == 0x0004 {
idLen := binary.BigEndian.Uint16(data[13:15])
preparedID := string(data[15 : 15+idLen])
log.Debugf("Result with prepared-id = '%s' for stream-id %d", preparedID, streamID)
path := p.preparedQueryPathByStreamID[streamID]
if len(path) > 0 {
// found cached query path to associate with this preparedID
p.preparedQueryPathByPreparedID[preparedID] = path
log.Debugf("Associating query path '%s' with prepared-id %s as part of stream-id %d", path, preparedID, streamID)
} else {
log.Warnf("Unable to find prepared query path associated with stream-id %d", streamID)
}
}
}
} | go | func cassandraParseReply(p *CassandraParser, data []byte) {
direction := data[0] & 0x80 // top bit
if direction != 0x80 {
log.Errorf("Direction bit is 'request', but we are trying to parse a reply")
return
}
compressionFlag := data[1] & 0x01
if compressionFlag == 1 {
log.Errorf("Compression flag set, unable to parse reply beyond the header")
return
}
streamID := binary.BigEndian.Uint16(data[2:4])
log.Debugf("Reply with opcode %d and stream-id %d", data[4], streamID)
// if this is an opcode == RESULT message of type 'prepared', associate the prepared
// statement id with the full query string that was included in the
// associated PREPARE request. The stream-id in this reply allows us to
// find the associated prepare query string.
if data[4] == 0x08 {
resultKind := binary.BigEndian.Uint32(data[9:13])
log.Debugf("resultKind = %d", resultKind)
if resultKind == 0x0004 {
idLen := binary.BigEndian.Uint16(data[13:15])
preparedID := string(data[15 : 15+idLen])
log.Debugf("Result with prepared-id = '%s' for stream-id %d", preparedID, streamID)
path := p.preparedQueryPathByStreamID[streamID]
if len(path) > 0 {
// found cached query path to associate with this preparedID
p.preparedQueryPathByPreparedID[preparedID] = path
log.Debugf("Associating query path '%s' with prepared-id %s as part of stream-id %d", path, preparedID, streamID)
} else {
log.Warnf("Unable to find prepared query path associated with stream-id %d", streamID)
}
}
}
} | [
"func",
"cassandraParseReply",
"(",
"p",
"*",
"CassandraParser",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"direction",
":=",
"data",
"[",
"0",
"]",
"&",
"0x80",
"// top bit",
"\n",
"if",
"direction",
"!=",
"0x80",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"compressionFlag",
":=",
"data",
"[",
"1",
"]",
"&",
"0x01",
"\n",
"if",
"compressionFlag",
"==",
"1",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"streamID",
":=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"data",
"[",
"2",
":",
"4",
"]",
")",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"data",
"[",
"4",
"]",
",",
"streamID",
")",
"\n",
"// if this is an opcode == RESULT message of type 'prepared', associate the prepared",
"// statement id with the full query string that was included in the",
"// associated PREPARE request. The stream-id in this reply allows us to",
"// find the associated prepare query string.",
"if",
"data",
"[",
"4",
"]",
"==",
"0x08",
"{",
"resultKind",
":=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"data",
"[",
"9",
":",
"13",
"]",
")",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"resultKind",
")",
"\n",
"if",
"resultKind",
"==",
"0x0004",
"{",
"idLen",
":=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"data",
"[",
"13",
":",
"15",
"]",
")",
"\n",
"preparedID",
":=",
"string",
"(",
"data",
"[",
"15",
":",
"15",
"+",
"idLen",
"]",
")",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"preparedID",
",",
"streamID",
")",
"\n",
"path",
":=",
"p",
".",
"preparedQueryPathByStreamID",
"[",
"streamID",
"]",
"\n",
"if",
"len",
"(",
"path",
")",
">",
"0",
"{",
"// found cached query path to associate with this preparedID",
"p",
".",
"preparedQueryPathByPreparedID",
"[",
"preparedID",
"]",
"=",
"path",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"path",
",",
"preparedID",
",",
"streamID",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"streamID",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // reply parsing is very basic, just focusing on parsing RESULT messages that
// contain prepared query IDs so that we can later enforce policy on "execute" requests. | [
"reply",
"parsing",
"is",
"very",
"basic",
"just",
"focusing",
"on",
"parsing",
"RESULT",
"messages",
"that",
"contain",
"prepared",
"query",
"IDs",
"so",
"that",
"we",
"can",
"later",
"enforce",
"policy",
"on",
"execute",
"requests",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/cassandra/cassandraparser.go#L676-L713 |
163,450 | cilium/cilium | pkg/policy/distillery/distillery.go | lookupOrCreate | func (cache *policyCache) lookupOrCreate(identity *identityPkg.Identity, create bool) (SelectorPolicy, bool) {
cache.Lock()
defer cache.Unlock()
cip, ok := cache.policies[identity.ID]
if create && !ok {
cip = newCachedSelectorPolicy(identity)
cache.policies[identity.ID] = cip
}
computed := false
if cip != nil {
computed = cip.getPolicy().Revision > 0
}
return cip, computed
} | go | func (cache *policyCache) lookupOrCreate(identity *identityPkg.Identity, create bool) (SelectorPolicy, bool) {
cache.Lock()
defer cache.Unlock()
cip, ok := cache.policies[identity.ID]
if create && !ok {
cip = newCachedSelectorPolicy(identity)
cache.policies[identity.ID] = cip
}
computed := false
if cip != nil {
computed = cip.getPolicy().Revision > 0
}
return cip, computed
} | [
"func",
"(",
"cache",
"*",
"policyCache",
")",
"lookupOrCreate",
"(",
"identity",
"*",
"identityPkg",
".",
"Identity",
",",
"create",
"bool",
")",
"(",
"SelectorPolicy",
",",
"bool",
")",
"{",
"cache",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cache",
".",
"Unlock",
"(",
")",
"\n",
"cip",
",",
"ok",
":=",
"cache",
".",
"policies",
"[",
"identity",
".",
"ID",
"]",
"\n",
"if",
"create",
"&&",
"!",
"ok",
"{",
"cip",
"=",
"newCachedSelectorPolicy",
"(",
"identity",
")",
"\n",
"cache",
".",
"policies",
"[",
"identity",
".",
"ID",
"]",
"=",
"cip",
"\n",
"}",
"\n\n",
"computed",
":=",
"false",
"\n",
"if",
"cip",
"!=",
"nil",
"{",
"computed",
"=",
"cip",
".",
"getPolicy",
"(",
")",
".",
"Revision",
">",
"0",
"\n",
"}",
"\n",
"return",
"cip",
",",
"computed",
"\n",
"}"
] | // lookupOrCreate adds the specified Identity to the policy cache, with a reference
// from the specified Endpoint, then returns the threadsafe copy of the policy
// and whether policy has been computed for this identity. | [
"lookupOrCreate",
"adds",
"the",
"specified",
"Identity",
"to",
"the",
"policy",
"cache",
"with",
"a",
"reference",
"from",
"the",
"specified",
"Endpoint",
"then",
"returns",
"the",
"threadsafe",
"copy",
"of",
"the",
"policy",
"and",
"whether",
"policy",
"has",
"been",
"computed",
"for",
"this",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L61-L75 |
163,451 | cilium/cilium | pkg/policy/distillery/distillery.go | insert | func (cache *policyCache) insert(identity *identityPkg.Identity) (SelectorPolicy, bool) {
return cache.lookupOrCreate(identity, true)
} | go | func (cache *policyCache) insert(identity *identityPkg.Identity) (SelectorPolicy, bool) {
return cache.lookupOrCreate(identity, true)
} | [
"func",
"(",
"cache",
"*",
"policyCache",
")",
"insert",
"(",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"(",
"SelectorPolicy",
",",
"bool",
")",
"{",
"return",
"cache",
".",
"lookupOrCreate",
"(",
"identity",
",",
"true",
")",
"\n",
"}"
] | // insert adds the specified Identity to the policy cache, with a reference
// from the specified Endpoint, then returns the threadsafe copy of the policy
// and whether policy has been computed for this identity. | [
"insert",
"adds",
"the",
"specified",
"Identity",
"to",
"the",
"policy",
"cache",
"with",
"a",
"reference",
"from",
"the",
"specified",
"Endpoint",
"then",
"returns",
"the",
"threadsafe",
"copy",
"of",
"the",
"policy",
"and",
"whether",
"policy",
"has",
"been",
"computed",
"for",
"this",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L80-L82 |
163,452 | cilium/cilium | pkg/policy/distillery/distillery.go | delete | func (cache *policyCache) delete(identity *identityPkg.Identity) bool {
cache.Lock()
defer cache.Unlock()
_, ok := cache.policies[identity.ID]
if ok {
delete(cache.policies, identity.ID)
}
return ok
} | go | func (cache *policyCache) delete(identity *identityPkg.Identity) bool {
cache.Lock()
defer cache.Unlock()
_, ok := cache.policies[identity.ID]
if ok {
delete(cache.policies, identity.ID)
}
return ok
} | [
"func",
"(",
"cache",
"*",
"policyCache",
")",
"delete",
"(",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"bool",
"{",
"cache",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cache",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"ok",
":=",
"cache",
".",
"policies",
"[",
"identity",
".",
"ID",
"]",
"\n",
"if",
"ok",
"{",
"delete",
"(",
"cache",
".",
"policies",
",",
"identity",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"ok",
"\n",
"}"
] | // delete forgets about any cached SelectorPolicy that this endpoint uses.
//
// Returns true if the SelectorPolicy was removed from the cache. | [
"delete",
"forgets",
"about",
"any",
"cached",
"SelectorPolicy",
"that",
"this",
"endpoint",
"uses",
".",
"Returns",
"true",
"if",
"the",
"SelectorPolicy",
"was",
"removed",
"from",
"the",
"cache",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L87-L95 |
163,453 | cilium/cilium | pkg/policy/distillery/distillery.go | updateSelectorPolicy | func (cache *policyCache) updateSelectorPolicy(repo PolicyRepository, identity *identityPkg.Identity) (bool, error) {
revision := repo.GetRevision()
cache.Lock()
cip, ok := cache.policies[identity.ID]
cache.Unlock()
if !ok {
return false, fmt.Errorf("SelectorPolicy not found in cache for ID %d", identity.ID)
}
// Don't resolve policy if it was already done for this Identity.
currentRevision := cip.getPolicy().Revision
if revision <= currentRevision {
return false, nil
}
// Resolve the policies, which could fail
identityPolicy, err := repo.ResolvePolicyLocked(identity)
if err != nil {
return false, err
}
// We don't cover the ResolvePolicyLocked() call above with the cache
// Mutex because it's potentially expensive, and endpoints with
// different identities should be able to concurrently compute policy.
//
// However, as long as UpdatePolicy() is triggered from endpoint
// regeneration, it's possible for two endpoints with the *same*
// identity to race to the revision check above, both find that the
// policy is out-of-date, and resolve the policy then race down to
// here. Set the pointer to the latest revision in both cases.
//
// Note that because repo.Mutex is held, the two racing threads will be
// guaranteed to compute policy for the same revision of the policy.
// We could save some CPU by, for example, forcing resolution of policy
// for the same identity to block on a channel/lock, but this is
// skipped for now as there are upcoming changes to the cache update
// logic which would render such mechanisms obsolete.
changed := revision > currentRevision
if changed {
cip.setPolicy(identityPolicy)
}
return changed, nil
} | go | func (cache *policyCache) updateSelectorPolicy(repo PolicyRepository, identity *identityPkg.Identity) (bool, error) {
revision := repo.GetRevision()
cache.Lock()
cip, ok := cache.policies[identity.ID]
cache.Unlock()
if !ok {
return false, fmt.Errorf("SelectorPolicy not found in cache for ID %d", identity.ID)
}
// Don't resolve policy if it was already done for this Identity.
currentRevision := cip.getPolicy().Revision
if revision <= currentRevision {
return false, nil
}
// Resolve the policies, which could fail
identityPolicy, err := repo.ResolvePolicyLocked(identity)
if err != nil {
return false, err
}
// We don't cover the ResolvePolicyLocked() call above with the cache
// Mutex because it's potentially expensive, and endpoints with
// different identities should be able to concurrently compute policy.
//
// However, as long as UpdatePolicy() is triggered from endpoint
// regeneration, it's possible for two endpoints with the *same*
// identity to race to the revision check above, both find that the
// policy is out-of-date, and resolve the policy then race down to
// here. Set the pointer to the latest revision in both cases.
//
// Note that because repo.Mutex is held, the two racing threads will be
// guaranteed to compute policy for the same revision of the policy.
// We could save some CPU by, for example, forcing resolution of policy
// for the same identity to block on a channel/lock, but this is
// skipped for now as there are upcoming changes to the cache update
// logic which would render such mechanisms obsolete.
changed := revision > currentRevision
if changed {
cip.setPolicy(identityPolicy)
}
return changed, nil
} | [
"func",
"(",
"cache",
"*",
"policyCache",
")",
"updateSelectorPolicy",
"(",
"repo",
"PolicyRepository",
",",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"(",
"bool",
",",
"error",
")",
"{",
"revision",
":=",
"repo",
".",
"GetRevision",
"(",
")",
"\n\n",
"cache",
".",
"Lock",
"(",
")",
"\n",
"cip",
",",
"ok",
":=",
"cache",
".",
"policies",
"[",
"identity",
".",
"ID",
"]",
"\n",
"cache",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"identity",
".",
"ID",
")",
"\n",
"}",
"\n\n",
"// Don't resolve policy if it was already done for this Identity.",
"currentRevision",
":=",
"cip",
".",
"getPolicy",
"(",
")",
".",
"Revision",
"\n",
"if",
"revision",
"<=",
"currentRevision",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"// Resolve the policies, which could fail",
"identityPolicy",
",",
"err",
":=",
"repo",
".",
"ResolvePolicyLocked",
"(",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"// We don't cover the ResolvePolicyLocked() call above with the cache",
"// Mutex because it's potentially expensive, and endpoints with",
"// different identities should be able to concurrently compute policy.",
"//",
"// However, as long as UpdatePolicy() is triggered from endpoint",
"// regeneration, it's possible for two endpoints with the *same*",
"// identity to race to the revision check above, both find that the",
"// policy is out-of-date, and resolve the policy then race down to",
"// here. Set the pointer to the latest revision in both cases.",
"//",
"// Note that because repo.Mutex is held, the two racing threads will be",
"// guaranteed to compute policy for the same revision of the policy.",
"// We could save some CPU by, for example, forcing resolution of policy",
"// for the same identity to block on a channel/lock, but this is",
"// skipped for now as there are upcoming changes to the cache update",
"// logic which would render such mechanisms obsolete.",
"changed",
":=",
"revision",
">",
"currentRevision",
"\n",
"if",
"changed",
"{",
"cip",
".",
"setPolicy",
"(",
"identityPolicy",
")",
"\n",
"}",
"\n",
"return",
"changed",
",",
"nil",
"\n",
"}"
] | // updateSelectorPolicy resolves the policy for the security identity of the
// specified endpoint and stores it internally. It will skip policy resolution
// if the cached policy is already at the revision specified in the repo.
//
// Returns whether the cache was updated, or an error.
//
// Must be called with repo.Mutex held for reading. | [
"updateSelectorPolicy",
"resolves",
"the",
"policy",
"for",
"the",
"security",
"identity",
"of",
"the",
"specified",
"endpoint",
"and",
"stores",
"it",
"internally",
".",
"It",
"will",
"skip",
"policy",
"resolution",
"if",
"the",
"cached",
"policy",
"is",
"already",
"at",
"the",
"revision",
"specified",
"in",
"the",
"repo",
".",
"Returns",
"whether",
"the",
"cache",
"was",
"updated",
"or",
"an",
"error",
".",
"Must",
"be",
"called",
"with",
"repo",
".",
"Mutex",
"held",
"for",
"reading",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L104-L147 |
163,454 | cilium/cilium | pkg/policy/distillery/distillery.go | Lookup | func Lookup(identity *identityPkg.Identity) SelectorPolicy {
cip, _ := globalPolicyCache.lookupOrCreate(identity, false)
return cip
} | go | func Lookup(identity *identityPkg.Identity) SelectorPolicy {
cip, _ := globalPolicyCache.lookupOrCreate(identity, false)
return cip
} | [
"func",
"Lookup",
"(",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"SelectorPolicy",
"{",
"cip",
",",
"_",
":=",
"globalPolicyCache",
".",
"lookupOrCreate",
"(",
"identity",
",",
"false",
")",
"\n",
"return",
"cip",
"\n",
"}"
] | // Lookup attempts to locate the SelectorPolicy corresponding to the specified
// identity. If policy is not cached for the identity, it returns nil. | [
"Lookup",
"attempts",
"to",
"locate",
"the",
"SelectorPolicy",
"corresponding",
"to",
"the",
"specified",
"identity",
".",
"If",
"policy",
"is",
"not",
"cached",
"for",
"the",
"identity",
"it",
"returns",
"nil",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L163-L166 |
163,455 | cilium/cilium | pkg/policy/distillery/distillery.go | UpdatePolicy | func UpdatePolicy(repo PolicyRepository, identity *identityPkg.Identity) error {
_, err := globalPolicyCache.updateSelectorPolicy(repo, identity)
return err
} | go | func UpdatePolicy(repo PolicyRepository, identity *identityPkg.Identity) error {
_, err := globalPolicyCache.updateSelectorPolicy(repo, identity)
return err
} | [
"func",
"UpdatePolicy",
"(",
"repo",
"PolicyRepository",
",",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"error",
"{",
"_",
",",
"err",
":=",
"globalPolicyCache",
".",
"updateSelectorPolicy",
"(",
"repo",
",",
"identity",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // UpdatePolicy resolves the policy for the security identity of the specified
// endpoint and caches it for future use.
//
// The caller must provide threadsafety for iteration over the provided policy
// repository. | [
"UpdatePolicy",
"resolves",
"the",
"policy",
"for",
"the",
"security",
"identity",
"of",
"the",
"specified",
"endpoint",
"and",
"caches",
"it",
"for",
"future",
"use",
".",
"The",
"caller",
"must",
"provide",
"threadsafety",
"for",
"iteration",
"over",
"the",
"provided",
"policy",
"repository",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/distillery/distillery.go#L180-L183 |
163,456 | cilium/cilium | pkg/checker/checker.go | Check | func (checker *diffChecker) Check(params []interface{}, names []string) (result bool, error string) {
if len(params) != 2 || len(names) != 2 {
return false, "params and names must be of length 2"
}
if reflect.DeepEqual(params[0], params[1]) {
return true, ""
}
return false, comparator.CompareWithNames(params[0], params[1], names[0], names[1])
} | go | func (checker *diffChecker) Check(params []interface{}, names []string) (result bool, error string) {
if len(params) != 2 || len(names) != 2 {
return false, "params and names must be of length 2"
}
if reflect.DeepEqual(params[0], params[1]) {
return true, ""
}
return false, comparator.CompareWithNames(params[0], params[1], names[0], names[1])
} | [
"func",
"(",
"checker",
"*",
"diffChecker",
")",
"Check",
"(",
"params",
"[",
"]",
"interface",
"{",
"}",
",",
"names",
"[",
"]",
"string",
")",
"(",
"result",
"bool",
",",
"error",
"string",
")",
"{",
"if",
"len",
"(",
"params",
")",
"!=",
"2",
"||",
"len",
"(",
"names",
")",
"!=",
"2",
"{",
"return",
"false",
",",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"reflect",
".",
"DeepEqual",
"(",
"params",
"[",
"0",
"]",
",",
"params",
"[",
"1",
"]",
")",
"{",
"return",
"true",
",",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"comparator",
".",
"CompareWithNames",
"(",
"params",
"[",
"0",
"]",
",",
"params",
"[",
"1",
"]",
",",
"names",
"[",
"0",
"]",
",",
"names",
"[",
"1",
"]",
")",
"\n",
"}"
] | // Check performs a diff between two objects provided as parameters, and
// returns either true if the objects are identical, or false otherwise. If
// it returns false, it also returns the unified diff between the expected
// and obtained output. | [
"Check",
"performs",
"a",
"diff",
"between",
"two",
"objects",
"provided",
"as",
"parameters",
"and",
"returns",
"either",
"true",
"if",
"the",
"objects",
"are",
"identical",
"or",
"false",
"otherwise",
".",
"If",
"it",
"returns",
"false",
"it",
"also",
"returns",
"the",
"unified",
"diff",
"between",
"the",
"expected",
"and",
"obtained",
"output",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/checker/checker.go#L43-L53 |
163,457 | cilium/cilium | pkg/k8s/cnp.go | getUpdatedCNPFromStore | func (c *CNPStatusUpdateContext) getUpdatedCNPFromStore(cnp *types.SlimCNP) (*types.SlimCNP, error) {
serverRuleStore, exists, err := c.CiliumV2Store.Get(cnp)
if err != nil {
return nil, fmt.Errorf("unable to find v2.CiliumNetworkPolicy in local cache: %s", err)
}
if !exists {
return nil, errors.New("v2.CiliumNetworkPolicy does not exist in local cache")
}
serverRule, ok := serverRuleStore.(*types.SlimCNP)
if !ok {
return nil, errors.New("Received object of unknown type from API server, expecting v2.CiliumNetworkPolicy")
}
return serverRule, nil
} | go | func (c *CNPStatusUpdateContext) getUpdatedCNPFromStore(cnp *types.SlimCNP) (*types.SlimCNP, error) {
serverRuleStore, exists, err := c.CiliumV2Store.Get(cnp)
if err != nil {
return nil, fmt.Errorf("unable to find v2.CiliumNetworkPolicy in local cache: %s", err)
}
if !exists {
return nil, errors.New("v2.CiliumNetworkPolicy does not exist in local cache")
}
serverRule, ok := serverRuleStore.(*types.SlimCNP)
if !ok {
return nil, errors.New("Received object of unknown type from API server, expecting v2.CiliumNetworkPolicy")
}
return serverRule, nil
} | [
"func",
"(",
"c",
"*",
"CNPStatusUpdateContext",
")",
"getUpdatedCNPFromStore",
"(",
"cnp",
"*",
"types",
".",
"SlimCNP",
")",
"(",
"*",
"types",
".",
"SlimCNP",
",",
"error",
")",
"{",
"serverRuleStore",
",",
"exists",
",",
"err",
":=",
"c",
".",
"CiliumV2Store",
".",
"Get",
"(",
"cnp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"exists",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"serverRule",
",",
"ok",
":=",
"serverRuleStore",
".",
"(",
"*",
"types",
".",
"SlimCNP",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"serverRule",
",",
"nil",
"\n",
"}"
] | // getUpdatedCNPFromStore gets the most recent version of cnp from the store
// ciliumV2Store, which is updated by the Kubernetes watcher. This reduces
// the possibility of Cilium trying to update cnp in Kubernetes which has
// been updated between the time the watcher in this Cilium instance has
// received cnp, and when this function is called. This still may occur, though
// and users of the returned CiliumNetworkPolicy may not be able to update
// the cnp because it may become out-of-date. Returns an error if the CNP cannot
// be retrieved from the store, or the object retrieved from the store is not of
// the expected type. | [
"getUpdatedCNPFromStore",
"gets",
"the",
"most",
"recent",
"version",
"of",
"cnp",
"from",
"the",
"store",
"ciliumV2Store",
"which",
"is",
"updated",
"by",
"the",
"Kubernetes",
"watcher",
".",
"This",
"reduces",
"the",
"possibility",
"of",
"Cilium",
"trying",
"to",
"update",
"cnp",
"in",
"Kubernetes",
"which",
"has",
"been",
"updated",
"between",
"the",
"time",
"the",
"watcher",
"in",
"this",
"Cilium",
"instance",
"has",
"received",
"cnp",
"and",
"when",
"this",
"function",
"is",
"called",
".",
"This",
"still",
"may",
"occur",
"though",
"and",
"users",
"of",
"the",
"returned",
"CiliumNetworkPolicy",
"may",
"not",
"be",
"able",
"to",
"update",
"the",
"cnp",
"because",
"it",
"may",
"become",
"out",
"-",
"of",
"-",
"date",
".",
"Returns",
"an",
"error",
"if",
"the",
"CNP",
"cannot",
"be",
"retrieved",
"from",
"the",
"store",
"or",
"the",
"object",
"retrieved",
"from",
"the",
"store",
"is",
"not",
"of",
"the",
"expected",
"type",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/cnp.go#L94-L109 |
163,458 | cilium/cilium | pkg/k8s/cnp.go | UpdateStatus | func (c *CNPStatusUpdateContext) UpdateStatus(ctx context.Context, cnp *types.SlimCNP, rev uint64, policyImportErr error) error {
var (
err error
serverRule *types.SlimCNP
// The following is an example distribution with jitter applied:
//
// nodes 4 16 128 512 1024 2048
// 1: 2.6s 5.5s 8.1s 9s 9.9s 12.9s
// 2: 1.9s 4.2s 6.3s 11.9s 17.6s 26.2s
// 3: 4s 10.4s 15.7s 26.7s 20.7s 23.3s
// 4: 18s 12.1s 19.7s 40s 1m6.3s 1m46.3s
// 5: 16.2s 28.9s 1m58.2s 46.2s 2m0s 2m0s
// 6: 54.7s 7.9s 53.3s 2m0s 2m0s 45.8s
// 7: 1m55.5s 22.8s 2m0s 2m0s 2m0s 2m0s
// 8: 1m45.8s 1m36.7s 2m0s 2m0s 2m0s 2m0s
cnpBackoff = backoff.Exponential{
Min: time.Second,
NodeManager: c.NodeManager,
Jitter: true,
}
scopedLog = log.WithFields(logrus.Fields{
logfields.CiliumNetworkPolicyName: cnp.ObjectMeta.Name,
logfields.K8sAPIVersion: cnp.TypeMeta.APIVersion,
logfields.K8sNamespace: cnp.ObjectMeta.Namespace,
})
)
ctxEndpointWait, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
waitForEPsErr := c.WaitForEndpointsAtPolicyRev(ctxEndpointWait, rev)
numAttempts := 0
retryLoop:
for {
numAttempts++
select {
case <-ctx.Done():
// The owning controller wants us to stop, no error is
// returned. This is graceful
err = fmt.Errorf("status update cancelled via context: %s", ctx.Err())
break retryLoop
default:
}
// Failure to prepare are returned as error immediately to
// expose them via the controller status as these errors are
// most likely not temporary.
// In case of a CNP parse error will update the status in the CNP.
serverRule, err = c.prepareUpdate(cnp, scopedLog)
if IsErrParse(err) {
statusErr := c.updateStatus(serverRule, rev, err, waitForEPsErr)
if statusErr != nil {
scopedLog.WithError(statusErr).Debug("CNP status for invalid rule cannot be updated")
}
}
if err != nil {
return err
}
err = c.updateStatus(serverRule, rev, policyImportErr, waitForEPsErr)
scopedLog.WithError(err).WithField("status", serverRule.Status).Debug("CNP status update result from apiserver")
switch {
case waitForEPsErr != nil:
// Waiting for endpoints has failed previously. We made
// an attempt to make this error condition visible via
// the status field. Regardless of whether this has
// succeeded or not, return an error to have the
// surrounding controller retry the wait for endpoint
// state.
err = waitForEPsErr
break retryLoop
case err == nil:
// The status update was successful
break retryLoop
}
cnpBackoff.Wait(ctx)
// error of Wait() can be ignored, if the context is cancelled,
// the next iteration of the loop will break out
}
outcome := metrics.LabelValueOutcomeSuccess
if err != nil {
outcome = metrics.LabelValueOutcomeFail
}
if c.UpdateDuration != nil {
latency := c.UpdateDuration.End(err == nil).Total()
metrics.KubernetesCNPStatusCompletion.WithLabelValues(fmt.Sprintf("%d", numAttempts), outcome).Observe(latency.Seconds())
}
return err
} | go | func (c *CNPStatusUpdateContext) UpdateStatus(ctx context.Context, cnp *types.SlimCNP, rev uint64, policyImportErr error) error {
var (
err error
serverRule *types.SlimCNP
// The following is an example distribution with jitter applied:
//
// nodes 4 16 128 512 1024 2048
// 1: 2.6s 5.5s 8.1s 9s 9.9s 12.9s
// 2: 1.9s 4.2s 6.3s 11.9s 17.6s 26.2s
// 3: 4s 10.4s 15.7s 26.7s 20.7s 23.3s
// 4: 18s 12.1s 19.7s 40s 1m6.3s 1m46.3s
// 5: 16.2s 28.9s 1m58.2s 46.2s 2m0s 2m0s
// 6: 54.7s 7.9s 53.3s 2m0s 2m0s 45.8s
// 7: 1m55.5s 22.8s 2m0s 2m0s 2m0s 2m0s
// 8: 1m45.8s 1m36.7s 2m0s 2m0s 2m0s 2m0s
cnpBackoff = backoff.Exponential{
Min: time.Second,
NodeManager: c.NodeManager,
Jitter: true,
}
scopedLog = log.WithFields(logrus.Fields{
logfields.CiliumNetworkPolicyName: cnp.ObjectMeta.Name,
logfields.K8sAPIVersion: cnp.TypeMeta.APIVersion,
logfields.K8sNamespace: cnp.ObjectMeta.Namespace,
})
)
ctxEndpointWait, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
waitForEPsErr := c.WaitForEndpointsAtPolicyRev(ctxEndpointWait, rev)
numAttempts := 0
retryLoop:
for {
numAttempts++
select {
case <-ctx.Done():
// The owning controller wants us to stop, no error is
// returned. This is graceful
err = fmt.Errorf("status update cancelled via context: %s", ctx.Err())
break retryLoop
default:
}
// Failure to prepare are returned as error immediately to
// expose them via the controller status as these errors are
// most likely not temporary.
// In case of a CNP parse error will update the status in the CNP.
serverRule, err = c.prepareUpdate(cnp, scopedLog)
if IsErrParse(err) {
statusErr := c.updateStatus(serverRule, rev, err, waitForEPsErr)
if statusErr != nil {
scopedLog.WithError(statusErr).Debug("CNP status for invalid rule cannot be updated")
}
}
if err != nil {
return err
}
err = c.updateStatus(serverRule, rev, policyImportErr, waitForEPsErr)
scopedLog.WithError(err).WithField("status", serverRule.Status).Debug("CNP status update result from apiserver")
switch {
case waitForEPsErr != nil:
// Waiting for endpoints has failed previously. We made
// an attempt to make this error condition visible via
// the status field. Regardless of whether this has
// succeeded or not, return an error to have the
// surrounding controller retry the wait for endpoint
// state.
err = waitForEPsErr
break retryLoop
case err == nil:
// The status update was successful
break retryLoop
}
cnpBackoff.Wait(ctx)
// error of Wait() can be ignored, if the context is cancelled,
// the next iteration of the loop will break out
}
outcome := metrics.LabelValueOutcomeSuccess
if err != nil {
outcome = metrics.LabelValueOutcomeFail
}
if c.UpdateDuration != nil {
latency := c.UpdateDuration.End(err == nil).Total()
metrics.KubernetesCNPStatusCompletion.WithLabelValues(fmt.Sprintf("%d", numAttempts), outcome).Observe(latency.Seconds())
}
return err
} | [
"func",
"(",
"c",
"*",
"CNPStatusUpdateContext",
")",
"UpdateStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnp",
"*",
"types",
".",
"SlimCNP",
",",
"rev",
"uint64",
",",
"policyImportErr",
"error",
")",
"error",
"{",
"var",
"(",
"err",
"error",
"\n",
"serverRule",
"*",
"types",
".",
"SlimCNP",
"\n\n",
"// The following is an example distribution with jitter applied:",
"//",
"// nodes 4 16 128 512 1024 2048",
"// 1: 2.6s 5.5s 8.1s 9s 9.9s 12.9s",
"// 2: 1.9s 4.2s 6.3s 11.9s 17.6s 26.2s",
"// 3: 4s 10.4s 15.7s 26.7s 20.7s 23.3s",
"// 4: 18s 12.1s 19.7s 40s 1m6.3s 1m46.3s",
"// 5: 16.2s 28.9s 1m58.2s 46.2s 2m0s 2m0s",
"// 6: 54.7s 7.9s 53.3s 2m0s 2m0s 45.8s",
"// 7: 1m55.5s 22.8s 2m0s 2m0s 2m0s 2m0s",
"// 8: 1m45.8s 1m36.7s 2m0s 2m0s 2m0s 2m0s",
"cnpBackoff",
"=",
"backoff",
".",
"Exponential",
"{",
"Min",
":",
"time",
".",
"Second",
",",
"NodeManager",
":",
"c",
".",
"NodeManager",
",",
"Jitter",
":",
"true",
",",
"}",
"\n\n",
"scopedLog",
"=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"CiliumNetworkPolicyName",
":",
"cnp",
".",
"ObjectMeta",
".",
"Name",
",",
"logfields",
".",
"K8sAPIVersion",
":",
"cnp",
".",
"TypeMeta",
".",
"APIVersion",
",",
"logfields",
".",
"K8sNamespace",
":",
"cnp",
".",
"ObjectMeta",
".",
"Namespace",
",",
"}",
")",
"\n",
")",
"\n",
"ctxEndpointWait",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"30",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"waitForEPsErr",
":=",
"c",
".",
"WaitForEndpointsAtPolicyRev",
"(",
"ctxEndpointWait",
",",
"rev",
")",
"\n\n",
"numAttempts",
":=",
"0",
"\n",
"retryLoop",
":",
"for",
"{",
"numAttempts",
"++",
"\n\n",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"// The owning controller wants us to stop, no error is",
"// returned. This is graceful",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ctx",
".",
"Err",
"(",
")",
")",
"\n",
"break",
"retryLoop",
"\n",
"default",
":",
"}",
"\n\n",
"// Failure to prepare are returned as error immediately to",
"// expose them via the controller status as these errors are",
"// most likely not temporary.",
"// In case of a CNP parse error will update the status in the CNP.",
"serverRule",
",",
"err",
"=",
"c",
".",
"prepareUpdate",
"(",
"cnp",
",",
"scopedLog",
")",
"\n",
"if",
"IsErrParse",
"(",
"err",
")",
"{",
"statusErr",
":=",
"c",
".",
"updateStatus",
"(",
"serverRule",
",",
"rev",
",",
"err",
",",
"waitForEPsErr",
")",
"\n",
"if",
"statusErr",
"!=",
"nil",
"{",
"scopedLog",
".",
"WithError",
"(",
"statusErr",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"c",
".",
"updateStatus",
"(",
"serverRule",
",",
"rev",
",",
"policyImportErr",
",",
"waitForEPsErr",
")",
"\n",
"scopedLog",
".",
"WithError",
"(",
"err",
")",
".",
"WithField",
"(",
"\"",
"\"",
",",
"serverRule",
".",
"Status",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"switch",
"{",
"case",
"waitForEPsErr",
"!=",
"nil",
":",
"// Waiting for endpoints has failed previously. We made",
"// an attempt to make this error condition visible via",
"// the status field. Regardless of whether this has",
"// succeeded or not, return an error to have the",
"// surrounding controller retry the wait for endpoint",
"// state.",
"err",
"=",
"waitForEPsErr",
"\n",
"break",
"retryLoop",
"\n\n",
"case",
"err",
"==",
"nil",
":",
"// The status update was successful",
"break",
"retryLoop",
"\n",
"}",
"\n\n",
"cnpBackoff",
".",
"Wait",
"(",
"ctx",
")",
"\n",
"// error of Wait() can be ignored, if the context is cancelled,",
"// the next iteration of the loop will break out",
"}",
"\n\n",
"outcome",
":=",
"metrics",
".",
"LabelValueOutcomeSuccess",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"outcome",
"=",
"metrics",
".",
"LabelValueOutcomeFail",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"UpdateDuration",
"!=",
"nil",
"{",
"latency",
":=",
"c",
".",
"UpdateDuration",
".",
"End",
"(",
"err",
"==",
"nil",
")",
".",
"Total",
"(",
")",
"\n",
"metrics",
".",
"KubernetesCNPStatusCompletion",
".",
"WithLabelValues",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"numAttempts",
")",
",",
"outcome",
")",
".",
"Observe",
"(",
"latency",
".",
"Seconds",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] | // UpdateStatus updates the status section of a CiliumNetworkPolicy. It will
// retry as long as required to update the status unless a non-temporary error
// occurs in which case it expects a surrounding controller to restart or give
// up. | [
"UpdateStatus",
"updates",
"the",
"status",
"section",
"of",
"a",
"CiliumNetworkPolicy",
".",
"It",
"will",
"retry",
"as",
"long",
"as",
"required",
"to",
"update",
"the",
"status",
"unless",
"a",
"non",
"-",
"temporary",
"error",
"occurs",
"in",
"which",
"case",
"it",
"expects",
"a",
"surrounding",
"controller",
"to",
"restart",
"or",
"give",
"up",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/cnp.go#L172-L269 |
163,459 | cilium/cilium | pkg/clustermesh/services.go | delete | func (c *globalServiceCache) delete(globalService *globalService, clusterName, serviceName string) {
scopedLog := log.WithFields(logrus.Fields{
logfields.ServiceName: serviceName,
logfields.ClusterName: clusterName,
})
if _, ok := globalService.clusterServices[clusterName]; !ok {
scopedLog.Debug("Ignoring delete request for unknown cluster")
return
}
scopedLog.Debugf("Deleted service definition of remote cluster")
delete(globalService.clusterServices, clusterName)
// After the last cluster service is removed, remove the
// global service
if len(globalService.clusterServices) == 0 {
scopedLog.Debugf("Deleted global service %s", serviceName)
delete(c.byName, serviceName)
}
} | go | func (c *globalServiceCache) delete(globalService *globalService, clusterName, serviceName string) {
scopedLog := log.WithFields(logrus.Fields{
logfields.ServiceName: serviceName,
logfields.ClusterName: clusterName,
})
if _, ok := globalService.clusterServices[clusterName]; !ok {
scopedLog.Debug("Ignoring delete request for unknown cluster")
return
}
scopedLog.Debugf("Deleted service definition of remote cluster")
delete(globalService.clusterServices, clusterName)
// After the last cluster service is removed, remove the
// global service
if len(globalService.clusterServices) == 0 {
scopedLog.Debugf("Deleted global service %s", serviceName)
delete(c.byName, serviceName)
}
} | [
"func",
"(",
"c",
"*",
"globalServiceCache",
")",
"delete",
"(",
"globalService",
"*",
"globalService",
",",
"clusterName",
",",
"serviceName",
"string",
")",
"{",
"scopedLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"ServiceName",
":",
"serviceName",
",",
"logfields",
".",
"ClusterName",
":",
"clusterName",
",",
"}",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"globalService",
".",
"clusterServices",
"[",
"clusterName",
"]",
";",
"!",
"ok",
"{",
"scopedLog",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"delete",
"(",
"globalService",
".",
"clusterServices",
",",
"clusterName",
")",
"\n\n",
"// After the last cluster service is removed, remove the",
"// global service",
"if",
"len",
"(",
"globalService",
".",
"clusterServices",
")",
"==",
"0",
"{",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"serviceName",
")",
"\n",
"delete",
"(",
"c",
".",
"byName",
",",
"serviceName",
")",
"\n",
"}",
"\n",
"}"
] | // must be called with c.mutex held | [
"must",
"be",
"called",
"with",
"c",
".",
"mutex",
"held"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/services.go#L78-L98 |
163,460 | cilium/cilium | pkg/clustermesh/services.go | OnUpdate | func (r *remoteServiceObserver) OnUpdate(key store.Key) {
if svc, ok := key.(*service.ClusterService); ok {
scopedLog := log.WithFields(logrus.Fields{logfields.ServiceName: svc.String()})
scopedLog.Debugf("Update event of remote service %#v", svc)
mesh := r.remoteCluster.mesh
mesh.globalServices.onUpdate(svc)
if merger := mesh.conf.ServiceMerger; merger != nil {
merger.MergeExternalServiceUpdate(svc)
} else {
scopedLog.Debugf("Ignoring remote service update. Missing merger function")
}
} else {
log.Warningf("Received unexpected remote service update object %+v", key)
}
} | go | func (r *remoteServiceObserver) OnUpdate(key store.Key) {
if svc, ok := key.(*service.ClusterService); ok {
scopedLog := log.WithFields(logrus.Fields{logfields.ServiceName: svc.String()})
scopedLog.Debugf("Update event of remote service %#v", svc)
mesh := r.remoteCluster.mesh
mesh.globalServices.onUpdate(svc)
if merger := mesh.conf.ServiceMerger; merger != nil {
merger.MergeExternalServiceUpdate(svc)
} else {
scopedLog.Debugf("Ignoring remote service update. Missing merger function")
}
} else {
log.Warningf("Received unexpected remote service update object %+v", key)
}
} | [
"func",
"(",
"r",
"*",
"remoteServiceObserver",
")",
"OnUpdate",
"(",
"key",
"store",
".",
"Key",
")",
"{",
"if",
"svc",
",",
"ok",
":=",
"key",
".",
"(",
"*",
"service",
".",
"ClusterService",
")",
";",
"ok",
"{",
"scopedLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"ServiceName",
":",
"svc",
".",
"String",
"(",
")",
"}",
")",
"\n",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"svc",
")",
"\n\n",
"mesh",
":=",
"r",
".",
"remoteCluster",
".",
"mesh",
"\n",
"mesh",
".",
"globalServices",
".",
"onUpdate",
"(",
"svc",
")",
"\n\n",
"if",
"merger",
":=",
"mesh",
".",
"conf",
".",
"ServiceMerger",
";",
"merger",
"!=",
"nil",
"{",
"merger",
".",
"MergeExternalServiceUpdate",
"(",
"svc",
")",
"\n",
"}",
"else",
"{",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}",
"\n",
"}"
] | // OnUpdate is called when a service in a remote cluster is updated | [
"OnUpdate",
"is",
"called",
"when",
"a",
"service",
"in",
"a",
"remote",
"cluster",
"is",
"updated"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/services.go#L129-L145 |
163,461 | cilium/cilium | pkg/clustermesh/services.go | OnDelete | func (r *remoteServiceObserver) OnDelete(key store.NamedKey) {
if svc, ok := key.(*service.ClusterService); ok {
scopedLog := log.WithFields(logrus.Fields{logfields.ServiceName: svc.String()})
scopedLog.Debugf("Update event of remote service %#v", svc)
mesh := r.remoteCluster.mesh
mesh.globalServices.onDelete(svc)
if merger := mesh.conf.ServiceMerger; merger != nil {
merger.MergeExternalServiceDelete(svc)
} else {
scopedLog.Debugf("Ignoring remote service update. Missing merger function")
}
} else {
log.Warningf("Received unexpected remote service delete object %+v", key)
}
} | go | func (r *remoteServiceObserver) OnDelete(key store.NamedKey) {
if svc, ok := key.(*service.ClusterService); ok {
scopedLog := log.WithFields(logrus.Fields{logfields.ServiceName: svc.String()})
scopedLog.Debugf("Update event of remote service %#v", svc)
mesh := r.remoteCluster.mesh
mesh.globalServices.onDelete(svc)
if merger := mesh.conf.ServiceMerger; merger != nil {
merger.MergeExternalServiceDelete(svc)
} else {
scopedLog.Debugf("Ignoring remote service update. Missing merger function")
}
} else {
log.Warningf("Received unexpected remote service delete object %+v", key)
}
} | [
"func",
"(",
"r",
"*",
"remoteServiceObserver",
")",
"OnDelete",
"(",
"key",
"store",
".",
"NamedKey",
")",
"{",
"if",
"svc",
",",
"ok",
":=",
"key",
".",
"(",
"*",
"service",
".",
"ClusterService",
")",
";",
"ok",
"{",
"scopedLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"ServiceName",
":",
"svc",
".",
"String",
"(",
")",
"}",
")",
"\n",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"svc",
")",
"\n\n",
"mesh",
":=",
"r",
".",
"remoteCluster",
".",
"mesh",
"\n",
"mesh",
".",
"globalServices",
".",
"onDelete",
"(",
"svc",
")",
"\n\n",
"if",
"merger",
":=",
"mesh",
".",
"conf",
".",
"ServiceMerger",
";",
"merger",
"!=",
"nil",
"{",
"merger",
".",
"MergeExternalServiceDelete",
"(",
"svc",
")",
"\n",
"}",
"else",
"{",
"scopedLog",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}",
"\n",
"}"
] | // OnDelete is called when a service in a remote cluster is deleted | [
"OnDelete",
"is",
"called",
"when",
"a",
"service",
"in",
"a",
"remote",
"cluster",
"is",
"deleted"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/clustermesh/services.go#L148-L164 |
163,462 | cilium/cilium | pkg/debug/subsystem.go | RegisterStatusFunc | func RegisterStatusFunc(name string, fn StatusFunc) error {
return globalStatusFunctions.register(name, fn)
} | go | func RegisterStatusFunc(name string, fn StatusFunc) error {
return globalStatusFunctions.register(name, fn)
} | [
"func",
"RegisterStatusFunc",
"(",
"name",
"string",
",",
"fn",
"StatusFunc",
")",
"error",
"{",
"return",
"globalStatusFunctions",
".",
"register",
"(",
"name",
",",
"fn",
")",
"\n",
"}"
] | // RegisterStatusFunc registers a subsystem and associates a status function to
// call for debug status collection | [
"RegisterStatusFunc",
"registers",
"a",
"subsystem",
"and",
"associates",
"a",
"status",
"function",
"to",
"call",
"for",
"debug",
"status",
"collection"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/debug/subsystem.go#L92-L94 |
163,463 | cilium/cilium | api/v1/client/policy/get_identity_endpoints_parameters.go | WithTimeout | func (o *GetIdentityEndpointsParams) WithTimeout(timeout time.Duration) *GetIdentityEndpointsParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetIdentityEndpointsParams) WithTimeout(timeout time.Duration) *GetIdentityEndpointsParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityEndpointsParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetIdentityEndpointsParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get identity endpoints params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"identity",
"endpoints",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/policy/get_identity_endpoints_parameters.go#L69-L72 |
163,464 | cilium/cilium | api/v1/client/policy/get_identity_endpoints_parameters.go | WithContext | func (o *GetIdentityEndpointsParams) WithContext(ctx context.Context) *GetIdentityEndpointsParams {
o.SetContext(ctx)
return o
} | go | func (o *GetIdentityEndpointsParams) WithContext(ctx context.Context) *GetIdentityEndpointsParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityEndpointsParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetIdentityEndpointsParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get identity endpoints params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"identity",
"endpoints",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/policy/get_identity_endpoints_parameters.go#L80-L83 |
163,465 | cilium/cilium | api/v1/client/policy/get_identity_endpoints_parameters.go | WithHTTPClient | func (o *GetIdentityEndpointsParams) WithHTTPClient(client *http.Client) *GetIdentityEndpointsParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetIdentityEndpointsParams) WithHTTPClient(client *http.Client) *GetIdentityEndpointsParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityEndpointsParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetIdentityEndpointsParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get identity endpoints params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"identity",
"endpoints",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/policy/get_identity_endpoints_parameters.go#L91-L94 |
163,466 | cilium/cilium | api/v1/models/service.go | Validate | func (m *Service) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateSpec(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatus(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *Service) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateSpec(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatus(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"Service",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateSpec",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateStatus",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this service | [
"Validate",
"validates",
"this",
"service"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/service.go#L27-L42 |
163,467 | cilium/cilium | api/v1/models/dns_lookup.go | Validate | func (m *DNSLookup) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateExpirationTime(formats); err != nil {
res = append(res, err)
}
if err := m.validateLookupTime(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *DNSLookup) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateExpirationTime(formats); err != nil {
res = append(res, err)
}
if err := m.validateLookupTime(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"DNSLookup",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateExpirationTime",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateLookupTime",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this DNS lookup | [
"Validate",
"validates",
"this",
"DNS",
"lookup"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/dns_lookup.go#L42-L57 |
163,468 | cilium/cilium | api/v1/models/endpoint_status_change.go | Validate | func (m *EndpointStatusChange) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCode(formats); err != nil {
res = append(res, err)
}
if err := m.validateState(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *EndpointStatusChange) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCode(formats); err != nil {
res = append(res, err)
}
if err := m.validateState(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"EndpointStatusChange",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCode",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateState",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this endpoint status change | [
"Validate",
"validates",
"this",
"endpoint",
"status",
"change"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/endpoint_status_change.go#L37-L52 |
163,469 | cilium/cilium | api/v1/server/restapi/daemon/get_map_name_responses.go | WithPayload | func (o *GetMapNameOK) WithPayload(payload *models.BPFMap) *GetMapNameOK {
o.Payload = payload
return o
} | go | func (o *GetMapNameOK) WithPayload(payload *models.BPFMap) *GetMapNameOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetMapNameOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"BPFMap",
")",
"*",
"GetMapNameOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get map name o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"map",
"name",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/daemon/get_map_name_responses.go#L38-L41 |
163,470 | cilium/cilium | cilium-health/launch/endpoint.go | PingEndpoint | func (c *Client) PingEndpoint() error {
_, err := c.Restapi.GetHello(nil)
return err
} | go | func (c *Client) PingEndpoint() error {
_, err := c.Restapi.GetHello(nil)
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PingEndpoint",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Restapi",
".",
"GetHello",
"(",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // PingEndpoint attempts to make an API ping request to the local cilium-health
// endpoint, and returns whether this was successful. | [
"PingEndpoint",
"attempts",
"to",
"make",
"an",
"API",
"ping",
"request",
"to",
"the",
"local",
"cilium",
"-",
"health",
"endpoint",
"and",
"returns",
"whether",
"this",
"was",
"successful",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium-health/launch/endpoint.go#L118-L121 |
163,471 | cilium/cilium | cilium-health/launch/endpoint.go | CleanupEndpoint | func CleanupEndpoint() {
// In the case of ipvlan, the ipvlan slave device is removed by removal
// of the endpoint netns in "cleanup" of spawn_netns.sh
if option.Config.DatapathMode == option.DatapathModeVeth {
scopedLog := log.WithField(logfields.Veth, vethName)
if link, err := netlink.LinkByName(vethName); err == nil {
err = netlink.LinkDel(link)
if err != nil {
scopedLog.WithError(err).Warning("Couldn't delete cilium-health device")
}
} else {
scopedLog.WithError(err).Debug("Didn't find existing device")
}
}
} | go | func CleanupEndpoint() {
// In the case of ipvlan, the ipvlan slave device is removed by removal
// of the endpoint netns in "cleanup" of spawn_netns.sh
if option.Config.DatapathMode == option.DatapathModeVeth {
scopedLog := log.WithField(logfields.Veth, vethName)
if link, err := netlink.LinkByName(vethName); err == nil {
err = netlink.LinkDel(link)
if err != nil {
scopedLog.WithError(err).Warning("Couldn't delete cilium-health device")
}
} else {
scopedLog.WithError(err).Debug("Didn't find existing device")
}
}
} | [
"func",
"CleanupEndpoint",
"(",
")",
"{",
"// In the case of ipvlan, the ipvlan slave device is removed by removal",
"// of the endpoint netns in \"cleanup\" of spawn_netns.sh",
"if",
"option",
".",
"Config",
".",
"DatapathMode",
"==",
"option",
".",
"DatapathModeVeth",
"{",
"scopedLog",
":=",
"log",
".",
"WithField",
"(",
"logfields",
".",
"Veth",
",",
"vethName",
")",
"\n",
"if",
"link",
",",
"err",
":=",
"netlink",
".",
"LinkByName",
"(",
"vethName",
")",
";",
"err",
"==",
"nil",
"{",
"err",
"=",
"netlink",
".",
"LinkDel",
"(",
"link",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"scopedLog",
".",
"WithError",
"(",
"err",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"scopedLog",
".",
"WithError",
"(",
"err",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // CleanupEndpoint cleans up remaining resources associated with the health
// endpoint.
//
// This is expected to be called after the process is killed and the endpoint
// is removed from the endpointmanager. | [
"CleanupEndpoint",
"cleans",
"up",
"remaining",
"resources",
"associated",
"with",
"the",
"health",
"endpoint",
".",
"This",
"is",
"expected",
"to",
"be",
"called",
"after",
"the",
"process",
"is",
"killed",
"and",
"the",
"endpoint",
"is",
"removed",
"from",
"the",
"endpointmanager",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium-health/launch/endpoint.go#L144-L158 |
163,472 | cilium/cilium | pkg/tuple/ipv4.go | Dump | func (k TupleKey4) Dump(buffer *bytes.Buffer, reverse bool) bool {
var addrDest string
if k.NextHeader == 0 {
return false
}
// Addresses swapped, see issue #5848
if reverse {
addrDest = k.SourceAddr.IP().String()
} else {
addrDest = k.DestAddr.IP().String()
}
if k.Flags&TUPLE_F_IN != 0 {
buffer.WriteString(fmt.Sprintf("%s IN %s %d:%d ",
k.NextHeader.String(), addrDest, k.SourcePort,
k.DestPort),
)
} else {
buffer.WriteString(fmt.Sprintf("%s OUT %s %d:%d ",
k.NextHeader.String(), addrDest, k.DestPort,
k.SourcePort),
)
}
if k.Flags&TUPLE_F_RELATED != 0 {
buffer.WriteString("related ")
}
if k.Flags&TUPLE_F_SERVICE != 0 {
buffer.WriteString("service ")
}
return true
} | go | func (k TupleKey4) Dump(buffer *bytes.Buffer, reverse bool) bool {
var addrDest string
if k.NextHeader == 0 {
return false
}
// Addresses swapped, see issue #5848
if reverse {
addrDest = k.SourceAddr.IP().String()
} else {
addrDest = k.DestAddr.IP().String()
}
if k.Flags&TUPLE_F_IN != 0 {
buffer.WriteString(fmt.Sprintf("%s IN %s %d:%d ",
k.NextHeader.String(), addrDest, k.SourcePort,
k.DestPort),
)
} else {
buffer.WriteString(fmt.Sprintf("%s OUT %s %d:%d ",
k.NextHeader.String(), addrDest, k.DestPort,
k.SourcePort),
)
}
if k.Flags&TUPLE_F_RELATED != 0 {
buffer.WriteString("related ")
}
if k.Flags&TUPLE_F_SERVICE != 0 {
buffer.WriteString("service ")
}
return true
} | [
"func",
"(",
"k",
"TupleKey4",
")",
"Dump",
"(",
"buffer",
"*",
"bytes",
".",
"Buffer",
",",
"reverse",
"bool",
")",
"bool",
"{",
"var",
"addrDest",
"string",
"\n\n",
"if",
"k",
".",
"NextHeader",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Addresses swapped, see issue #5848",
"if",
"reverse",
"{",
"addrDest",
"=",
"k",
".",
"SourceAddr",
".",
"IP",
"(",
")",
".",
"String",
"(",
")",
"\n",
"}",
"else",
"{",
"addrDest",
"=",
"k",
".",
"DestAddr",
".",
"IP",
"(",
")",
".",
"String",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"k",
".",
"Flags",
"&",
"TUPLE_F_IN",
"!=",
"0",
"{",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
".",
"NextHeader",
".",
"String",
"(",
")",
",",
"addrDest",
",",
"k",
".",
"SourcePort",
",",
"k",
".",
"DestPort",
")",
",",
")",
"\n",
"}",
"else",
"{",
"buffer",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
".",
"NextHeader",
".",
"String",
"(",
")",
",",
"addrDest",
",",
"k",
".",
"DestPort",
",",
"k",
".",
"SourcePort",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"k",
".",
"Flags",
"&",
"TUPLE_F_RELATED",
"!=",
"0",
"{",
"buffer",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"k",
".",
"Flags",
"&",
"TUPLE_F_SERVICE",
"!=",
"0",
"{",
"buffer",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // Dump writes the contents of key to buffer and returns true if the value for
// next header in the key is nonzero. | [
"Dump",
"writes",
"the",
"contents",
"of",
"key",
"to",
"buffer",
"and",
"returns",
"true",
"if",
"the",
"value",
"for",
"next",
"header",
"in",
"the",
"key",
"is",
"nonzero",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/tuple/ipv4.go#L74-L109 |
163,473 | cilium/cilium | pkg/tuple/ipv4.go | ToNetwork | func (k *TupleKey4Global) ToNetwork() TupleKey {
return &TupleKey4Global{
TupleKey4: *k.TupleKey4.ToNetwork().(*TupleKey4),
}
} | go | func (k *TupleKey4Global) ToNetwork() TupleKey {
return &TupleKey4Global{
TupleKey4: *k.TupleKey4.ToNetwork().(*TupleKey4),
}
} | [
"func",
"(",
"k",
"*",
"TupleKey4Global",
")",
"ToNetwork",
"(",
")",
"TupleKey",
"{",
"return",
"&",
"TupleKey4Global",
"{",
"TupleKey4",
":",
"*",
"k",
".",
"TupleKey4",
".",
"ToNetwork",
"(",
")",
".",
"(",
"*",
"TupleKey4",
")",
",",
"}",
"\n",
"}"
] | // ToNetwork converts ports to network byte order.
//
// This is necessary to prevent callers from implicitly converting
// the TupleKey4Global type here into a local key type in the nested
// TupleKey4 field. | [
"ToNetwork",
"converts",
"ports",
"to",
"network",
"byte",
"order",
".",
"This",
"is",
"necessary",
"to",
"prevent",
"callers",
"from",
"implicitly",
"converting",
"the",
"TupleKey4Global",
"type",
"here",
"into",
"a",
"local",
"key",
"type",
"in",
"the",
"nested",
"TupleKey4",
"field",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/tuple/ipv4.go#L132-L136 |
163,474 | cilium/cilium | pkg/tuple/ipv4.go | ToHost | func (k *TupleKey4Global) ToHost() TupleKey {
return &TupleKey4Global{
TupleKey4: *k.TupleKey4.ToHost().(*TupleKey4),
}
} | go | func (k *TupleKey4Global) ToHost() TupleKey {
return &TupleKey4Global{
TupleKey4: *k.TupleKey4.ToHost().(*TupleKey4),
}
} | [
"func",
"(",
"k",
"*",
"TupleKey4Global",
")",
"ToHost",
"(",
")",
"TupleKey",
"{",
"return",
"&",
"TupleKey4Global",
"{",
"TupleKey4",
":",
"*",
"k",
".",
"TupleKey4",
".",
"ToHost",
"(",
")",
".",
"(",
"*",
"TupleKey4",
")",
",",
"}",
"\n",
"}"
] | // ToHost converts ports to host byte order.
//
// This is necessary to prevent callers from implicitly converting
// the TupleKey4Global type here into a local key type in the nested
// TupleKey4 field. | [
"ToHost",
"converts",
"ports",
"to",
"host",
"byte",
"order",
".",
"This",
"is",
"necessary",
"to",
"prevent",
"callers",
"from",
"implicitly",
"converting",
"the",
"TupleKey4Global",
"type",
"here",
"into",
"a",
"local",
"key",
"type",
"in",
"the",
"nested",
"TupleKey4",
"field",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/tuple/ipv4.go#L143-L147 |
163,475 | cilium/cilium | api/v1/server/restapi/daemon/get_map.go | NewGetMap | func NewGetMap(ctx *middleware.Context, handler GetMapHandler) *GetMap {
return &GetMap{Context: ctx, Handler: handler}
} | go | func NewGetMap(ctx *middleware.Context, handler GetMapHandler) *GetMap {
return &GetMap{Context: ctx, Handler: handler}
} | [
"func",
"NewGetMap",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetMapHandler",
")",
"*",
"GetMap",
"{",
"return",
"&",
"GetMap",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetMap creates a new http.Handler for the get map operation | [
"NewGetMap",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"map",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/daemon/get_map.go#L28-L30 |
163,476 | cilium/cilium | api/v1/health/client/restapi/get_healthz_parameters.go | WithTimeout | func (o *GetHealthzParams) WithTimeout(timeout time.Duration) *GetHealthzParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetHealthzParams) WithTimeout(timeout time.Duration) *GetHealthzParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetHealthzParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetHealthzParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get healthz params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"healthz",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/client/restapi/get_healthz_parameters.go#L69-L72 |
163,477 | cilium/cilium | api/v1/health/client/restapi/get_healthz_parameters.go | WithContext | func (o *GetHealthzParams) WithContext(ctx context.Context) *GetHealthzParams {
o.SetContext(ctx)
return o
} | go | func (o *GetHealthzParams) WithContext(ctx context.Context) *GetHealthzParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetHealthzParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetHealthzParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get healthz params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"healthz",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/client/restapi/get_healthz_parameters.go#L80-L83 |
163,478 | cilium/cilium | api/v1/health/client/restapi/get_healthz_parameters.go | WithHTTPClient | func (o *GetHealthzParams) WithHTTPClient(client *http.Client) *GetHealthzParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetHealthzParams) WithHTTPClient(client *http.Client) *GetHealthzParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetHealthzParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetHealthzParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get healthz params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"healthz",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/client/restapi/get_healthz_parameters.go#L91-L94 |
163,479 | cilium/cilium | pkg/k8s/ingress.go | ParseIngressID | func ParseIngressID(svc *types.Ingress) ServiceID {
id := ServiceID{
Namespace: svc.ObjectMeta.Namespace,
}
if svc.Spec.Backend != nil {
id.Name = svc.Spec.Backend.ServiceName
}
return id
} | go | func ParseIngressID(svc *types.Ingress) ServiceID {
id := ServiceID{
Namespace: svc.ObjectMeta.Namespace,
}
if svc.Spec.Backend != nil {
id.Name = svc.Spec.Backend.ServiceName
}
return id
} | [
"func",
"ParseIngressID",
"(",
"svc",
"*",
"types",
".",
"Ingress",
")",
"ServiceID",
"{",
"id",
":=",
"ServiceID",
"{",
"Namespace",
":",
"svc",
".",
"ObjectMeta",
".",
"Namespace",
",",
"}",
"\n\n",
"if",
"svc",
".",
"Spec",
".",
"Backend",
"!=",
"nil",
"{",
"id",
".",
"Name",
"=",
"svc",
".",
"Spec",
".",
"Backend",
".",
"ServiceName",
"\n",
"}",
"\n\n",
"return",
"id",
"\n",
"}"
] | // ParseIngressID parses the service ID from the ingress resource | [
"ParseIngressID",
"parses",
"the",
"service",
"ID",
"from",
"the",
"ingress",
"resource"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/ingress.go#L32-L42 |
163,480 | cilium/cilium | pkg/k8s/ingress.go | ParseIngress | func ParseIngress(ingress *types.Ingress, host net.IP) (ServiceID, *Service, error) {
svcID := ParseIngressID(ingress)
if !supportV1beta1(ingress) {
return svcID, nil, fmt.Errorf("only Single Service Ingress is supported for now, ignoring Ingress")
}
ingressPort := ingress.Spec.Backend.ServicePort.IntValue()
if ingressPort == 0 {
return svcID, nil, fmt.Errorf("invalid port number")
}
svc := NewService(host, false, nil, nil)
portName := loadbalancer.FEPortName(ingress.Spec.Backend.ServiceName + "/" + ingress.Spec.Backend.ServicePort.String())
svc.Ports[portName] = loadbalancer.NewFEPort(loadbalancer.TCP, uint16(ingressPort))
return svcID, svc, nil
} | go | func ParseIngress(ingress *types.Ingress, host net.IP) (ServiceID, *Service, error) {
svcID := ParseIngressID(ingress)
if !supportV1beta1(ingress) {
return svcID, nil, fmt.Errorf("only Single Service Ingress is supported for now, ignoring Ingress")
}
ingressPort := ingress.Spec.Backend.ServicePort.IntValue()
if ingressPort == 0 {
return svcID, nil, fmt.Errorf("invalid port number")
}
svc := NewService(host, false, nil, nil)
portName := loadbalancer.FEPortName(ingress.Spec.Backend.ServiceName + "/" + ingress.Spec.Backend.ServicePort.String())
svc.Ports[portName] = loadbalancer.NewFEPort(loadbalancer.TCP, uint16(ingressPort))
return svcID, svc, nil
} | [
"func",
"ParseIngress",
"(",
"ingress",
"*",
"types",
".",
"Ingress",
",",
"host",
"net",
".",
"IP",
")",
"(",
"ServiceID",
",",
"*",
"Service",
",",
"error",
")",
"{",
"svcID",
":=",
"ParseIngressID",
"(",
"ingress",
")",
"\n\n",
"if",
"!",
"supportV1beta1",
"(",
"ingress",
")",
"{",
"return",
"svcID",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ingressPort",
":=",
"ingress",
".",
"Spec",
".",
"Backend",
".",
"ServicePort",
".",
"IntValue",
"(",
")",
"\n",
"if",
"ingressPort",
"==",
"0",
"{",
"return",
"svcID",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"svc",
":=",
"NewService",
"(",
"host",
",",
"false",
",",
"nil",
",",
"nil",
")",
"\n",
"portName",
":=",
"loadbalancer",
".",
"FEPortName",
"(",
"ingress",
".",
"Spec",
".",
"Backend",
".",
"ServiceName",
"+",
"\"",
"\"",
"+",
"ingress",
".",
"Spec",
".",
"Backend",
".",
"ServicePort",
".",
"String",
"(",
")",
")",
"\n",
"svc",
".",
"Ports",
"[",
"portName",
"]",
"=",
"loadbalancer",
".",
"NewFEPort",
"(",
"loadbalancer",
".",
"TCP",
",",
"uint16",
"(",
"ingressPort",
")",
")",
"\n\n",
"return",
"svcID",
",",
"svc",
",",
"nil",
"\n",
"}"
] | // ParseIngress parses an ingress resources and returns the Service definition | [
"ParseIngress",
"parses",
"an",
"ingress",
"resources",
"and",
"returns",
"the",
"Service",
"definition"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/ingress.go#L45-L62 |
163,481 | cilium/cilium | api/v1/server/restapi/endpoint/get_endpoint_id_labels.go | NewGetEndpointIDLabels | func NewGetEndpointIDLabels(ctx *middleware.Context, handler GetEndpointIDLabelsHandler) *GetEndpointIDLabels {
return &GetEndpointIDLabels{Context: ctx, Handler: handler}
} | go | func NewGetEndpointIDLabels(ctx *middleware.Context, handler GetEndpointIDLabelsHandler) *GetEndpointIDLabels {
return &GetEndpointIDLabels{Context: ctx, Handler: handler}
} | [
"func",
"NewGetEndpointIDLabels",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetEndpointIDLabelsHandler",
")",
"*",
"GetEndpointIDLabels",
"{",
"return",
"&",
"GetEndpointIDLabels",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetEndpointIDLabels creates a new http.Handler for the get endpoint ID labels operation | [
"NewGetEndpointIDLabels",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"endpoint",
"ID",
"labels",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/get_endpoint_id_labels.go#L28-L30 |
163,482 | cilium/cilium | api/v1/models/proxy_statistics.go | Validate | func (m *ProxyStatistics) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLocation(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatistics(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *ProxyStatistics) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLocation(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatistics(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"ProxyStatistics",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateLocation",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateStatistics",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this proxy statistics | [
"Validate",
"validates",
"this",
"proxy",
"statistics"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/proxy_statistics.go#L41-L56 |
163,483 | cilium/cilium | api/v1/server/restapi/policy/get_identity.go | NewGetIdentity | func NewGetIdentity(ctx *middleware.Context, handler GetIdentityHandler) *GetIdentity {
return &GetIdentity{Context: ctx, Handler: handler}
} | go | func NewGetIdentity(ctx *middleware.Context, handler GetIdentityHandler) *GetIdentity {
return &GetIdentity{Context: ctx, Handler: handler}
} | [
"func",
"NewGetIdentity",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetIdentityHandler",
")",
"*",
"GetIdentity",
"{",
"return",
"&",
"GetIdentity",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetIdentity creates a new http.Handler for the get identity operation | [
"NewGetIdentity",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"identity",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity.go#L28-L30 |
163,484 | cilium/cilium | api/v1/server/configure_cilium.go | setupGlobalMiddleware | func setupGlobalMiddleware(handler http.Handler) http.Handler {
eventsHelper := &metrics.APIEventTSHelper{
Next: handler,
TSGauge: metrics.EventTSAPI,
Histogram: metrics.APIInteractions,
}
return &api.APIPanicHandler{
Next: eventsHelper,
}
} | go | func setupGlobalMiddleware(handler http.Handler) http.Handler {
eventsHelper := &metrics.APIEventTSHelper{
Next: handler,
TSGauge: metrics.EventTSAPI,
Histogram: metrics.APIInteractions,
}
return &api.APIPanicHandler{
Next: eventsHelper,
}
} | [
"func",
"setupGlobalMiddleware",
"(",
"handler",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"eventsHelper",
":=",
"&",
"metrics",
".",
"APIEventTSHelper",
"{",
"Next",
":",
"handler",
",",
"TSGauge",
":",
"metrics",
".",
"EventTSAPI",
",",
"Histogram",
":",
"metrics",
".",
"APIInteractions",
",",
"}",
"\n\n",
"return",
"&",
"api",
".",
"APIPanicHandler",
"{",
"Next",
":",
"eventsHelper",
",",
"}",
"\n",
"}"
] | // The middleware configuration happens before anything, this middleware also applies to serving the swagger.json document.
// So this is a good place to plug in a panic handling middleware, logging and metrics | [
"The",
"middleware",
"configuration",
"happens",
"before",
"anything",
"this",
"middleware",
"also",
"applies",
"to",
"serving",
"the",
"swagger",
".",
"json",
"document",
".",
"So",
"this",
"is",
"a",
"good",
"place",
"to",
"plug",
"in",
"a",
"panic",
"handling",
"middleware",
"logging",
"and",
"metrics"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/configure_cilium.go#L62-L72 |
163,485 | cilium/cilium | pkg/monitor/datapath_trace.go | DumpInfo | func (n *TraceNotify) DumpInfo(data []byte) {
fmt.Printf("%s flow %#x identity %d->%d state %s ifindex %s: %s\n",
n.traceSummary(), n.Hash, n.SrcLabel, n.DstLabel,
connState(n.Reason), ifname(int(n.Ifindex)), GetConnectionSummary(data[TraceNotifyLen:]))
} | go | func (n *TraceNotify) DumpInfo(data []byte) {
fmt.Printf("%s flow %#x identity %d->%d state %s ifindex %s: %s\n",
n.traceSummary(), n.Hash, n.SrcLabel, n.DstLabel,
connState(n.Reason), ifname(int(n.Ifindex)), GetConnectionSummary(data[TraceNotifyLen:]))
} | [
"func",
"(",
"n",
"*",
"TraceNotify",
")",
"DumpInfo",
"(",
"data",
"[",
"]",
"byte",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"n",
".",
"traceSummary",
"(",
")",
",",
"n",
".",
"Hash",
",",
"n",
".",
"SrcLabel",
",",
"n",
".",
"DstLabel",
",",
"connState",
"(",
"n",
".",
"Reason",
")",
",",
"ifname",
"(",
"int",
"(",
"n",
".",
"Ifindex",
")",
")",
",",
"GetConnectionSummary",
"(",
"data",
"[",
"TraceNotifyLen",
":",
"]",
")",
")",
"\n",
"}"
] | // DumpInfo prints a summary of the trace messages. | [
"DumpInfo",
"prints",
"a",
"summary",
"of",
"the",
"trace",
"messages",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_trace.go#L128-L132 |
163,486 | cilium/cilium | pkg/monitor/datapath_trace.go | DumpVerbose | func (n *TraceNotify) DumpVerbose(dissect bool, data []byte, prefix string) {
fmt.Printf("%s MARK %#x FROM %d %s: %d bytes (%d captured), state %s",
prefix, n.Hash, n.Source, obsPoint(n.ObsPoint), n.OrigLen, n.CapLen, connState(n.Reason))
if n.Ifindex != 0 {
fmt.Printf(", interface %s", ifname(int(n.Ifindex)))
}
if n.SrcLabel != 0 || n.DstLabel != 0 {
fmt.Printf(", identity %d->%d", n.SrcLabel, n.DstLabel)
}
if n.DstID != 0 {
fmt.Printf(", to endpoint %d\n", n.DstID)
} else {
fmt.Printf("\n")
}
if n.CapLen > 0 && len(data) > TraceNotifyLen {
Dissect(dissect, data[TraceNotifyLen:])
}
} | go | func (n *TraceNotify) DumpVerbose(dissect bool, data []byte, prefix string) {
fmt.Printf("%s MARK %#x FROM %d %s: %d bytes (%d captured), state %s",
prefix, n.Hash, n.Source, obsPoint(n.ObsPoint), n.OrigLen, n.CapLen, connState(n.Reason))
if n.Ifindex != 0 {
fmt.Printf(", interface %s", ifname(int(n.Ifindex)))
}
if n.SrcLabel != 0 || n.DstLabel != 0 {
fmt.Printf(", identity %d->%d", n.SrcLabel, n.DstLabel)
}
if n.DstID != 0 {
fmt.Printf(", to endpoint %d\n", n.DstID)
} else {
fmt.Printf("\n")
}
if n.CapLen > 0 && len(data) > TraceNotifyLen {
Dissect(dissect, data[TraceNotifyLen:])
}
} | [
"func",
"(",
"n",
"*",
"TraceNotify",
")",
"DumpVerbose",
"(",
"dissect",
"bool",
",",
"data",
"[",
"]",
"byte",
",",
"prefix",
"string",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"prefix",
",",
"n",
".",
"Hash",
",",
"n",
".",
"Source",
",",
"obsPoint",
"(",
"n",
".",
"ObsPoint",
")",
",",
"n",
".",
"OrigLen",
",",
"n",
".",
"CapLen",
",",
"connState",
"(",
"n",
".",
"Reason",
")",
")",
"\n\n",
"if",
"n",
".",
"Ifindex",
"!=",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"ifname",
"(",
"int",
"(",
"n",
".",
"Ifindex",
")",
")",
")",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"SrcLabel",
"!=",
"0",
"||",
"n",
".",
"DstLabel",
"!=",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"n",
".",
"SrcLabel",
",",
"n",
".",
"DstLabel",
")",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"DstID",
"!=",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"n",
".",
"DstID",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"CapLen",
">",
"0",
"&&",
"len",
"(",
"data",
")",
">",
"TraceNotifyLen",
"{",
"Dissect",
"(",
"dissect",
",",
"data",
"[",
"TraceNotifyLen",
":",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // DumpVerbose prints the trace notification in human readable form | [
"DumpVerbose",
"prints",
"the",
"trace",
"notification",
"in",
"human",
"readable",
"form"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_trace.go#L135-L156 |
163,487 | cilium/cilium | pkg/monitor/datapath_trace.go | TraceNotifyToVerbose | func TraceNotifyToVerbose(n *TraceNotify) TraceNotifyVerbose {
return TraceNotifyVerbose{
Type: "trace",
Mark: fmt.Sprintf("%#x", n.Hash),
Ifindex: ifname(int(n.Ifindex)),
State: connState(n.Reason),
ObservationPoint: obsPoint(n.ObsPoint),
TraceSummary: n.traceSummary(),
Source: n.Source,
Bytes: n.OrigLen,
SrcLabel: n.SrcLabel,
DstLabel: n.DstLabel,
DstID: n.DstID,
}
} | go | func TraceNotifyToVerbose(n *TraceNotify) TraceNotifyVerbose {
return TraceNotifyVerbose{
Type: "trace",
Mark: fmt.Sprintf("%#x", n.Hash),
Ifindex: ifname(int(n.Ifindex)),
State: connState(n.Reason),
ObservationPoint: obsPoint(n.ObsPoint),
TraceSummary: n.traceSummary(),
Source: n.Source,
Bytes: n.OrigLen,
SrcLabel: n.SrcLabel,
DstLabel: n.DstLabel,
DstID: n.DstID,
}
} | [
"func",
"TraceNotifyToVerbose",
"(",
"n",
"*",
"TraceNotify",
")",
"TraceNotifyVerbose",
"{",
"return",
"TraceNotifyVerbose",
"{",
"Type",
":",
"\"",
"\"",
",",
"Mark",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"n",
".",
"Hash",
")",
",",
"Ifindex",
":",
"ifname",
"(",
"int",
"(",
"n",
".",
"Ifindex",
")",
")",
",",
"State",
":",
"connState",
"(",
"n",
".",
"Reason",
")",
",",
"ObservationPoint",
":",
"obsPoint",
"(",
"n",
".",
"ObsPoint",
")",
",",
"TraceSummary",
":",
"n",
".",
"traceSummary",
"(",
")",
",",
"Source",
":",
"n",
".",
"Source",
",",
"Bytes",
":",
"n",
".",
"OrigLen",
",",
"SrcLabel",
":",
"n",
".",
"SrcLabel",
",",
"DstLabel",
":",
"n",
".",
"DstLabel",
",",
"DstID",
":",
"n",
".",
"DstID",
",",
"}",
"\n",
"}"
] | // TraceNotifyToVerbose creates verbose notification from base TraceNotify | [
"TraceNotifyToVerbose",
"creates",
"verbose",
"notification",
"from",
"base",
"TraceNotify"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_trace.go#L197-L211 |
163,488 | cilium/cilium | api/v1/server/restapi/endpoint/patch_endpoint_id_labels.go | NewPatchEndpointIDLabels | func NewPatchEndpointIDLabels(ctx *middleware.Context, handler PatchEndpointIDLabelsHandler) *PatchEndpointIDLabels {
return &PatchEndpointIDLabels{Context: ctx, Handler: handler}
} | go | func NewPatchEndpointIDLabels(ctx *middleware.Context, handler PatchEndpointIDLabelsHandler) *PatchEndpointIDLabels {
return &PatchEndpointIDLabels{Context: ctx, Handler: handler}
} | [
"func",
"NewPatchEndpointIDLabels",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"PatchEndpointIDLabelsHandler",
")",
"*",
"PatchEndpointIDLabels",
"{",
"return",
"&",
"PatchEndpointIDLabels",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewPatchEndpointIDLabels creates a new http.Handler for the patch endpoint ID labels operation | [
"NewPatchEndpointIDLabels",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"patch",
"endpoint",
"ID",
"labels",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/patch_endpoint_id_labels.go#L28-L30 |
163,489 | cilium/cilium | pkg/datapath/prefilter/prefilter.go | WriteConfig | func (p *PreFilter) WriteConfig(fw io.Writer) {
p.mutex.RLock()
defer p.mutex.RUnlock()
fmt.Fprintf(fw, "#define CIDR4_HMAP_ELEMS %d\n", maxHKeys)
fmt.Fprintf(fw, "#define CIDR4_LMAP_ELEMS %d\n", maxLKeys)
fmt.Fprintf(fw, "#define CIDR4_HMAP_NAME %s\n", path.Base(p.maps[prefixesV4Fix].String()))
fmt.Fprintf(fw, "#define CIDR4_LMAP_NAME %s\n", path.Base(p.maps[prefixesV4Dyn].String()))
fmt.Fprintf(fw, "#define CIDR6_HMAP_NAME %s\n", path.Base(p.maps[prefixesV6Fix].String()))
fmt.Fprintf(fw, "#define CIDR6_LMAP_NAME %s\n", path.Base(p.maps[prefixesV6Dyn].String()))
if p.config.fix4Enabled {
fmt.Fprintf(fw, "#define CIDR4_FILTER\n")
if p.config.dyn4Enabled {
fmt.Fprintf(fw, "#define CIDR4_LPM_PREFILTER\n")
}
}
if p.config.fix6Enabled {
fmt.Fprintf(fw, "#define CIDR6_FILTER\n")
if p.config.dyn6Enabled {
fmt.Fprintf(fw, "#define CIDR6_LPM_PREFILTER\n")
}
}
} | go | func (p *PreFilter) WriteConfig(fw io.Writer) {
p.mutex.RLock()
defer p.mutex.RUnlock()
fmt.Fprintf(fw, "#define CIDR4_HMAP_ELEMS %d\n", maxHKeys)
fmt.Fprintf(fw, "#define CIDR4_LMAP_ELEMS %d\n", maxLKeys)
fmt.Fprintf(fw, "#define CIDR4_HMAP_NAME %s\n", path.Base(p.maps[prefixesV4Fix].String()))
fmt.Fprintf(fw, "#define CIDR4_LMAP_NAME %s\n", path.Base(p.maps[prefixesV4Dyn].String()))
fmt.Fprintf(fw, "#define CIDR6_HMAP_NAME %s\n", path.Base(p.maps[prefixesV6Fix].String()))
fmt.Fprintf(fw, "#define CIDR6_LMAP_NAME %s\n", path.Base(p.maps[prefixesV6Dyn].String()))
if p.config.fix4Enabled {
fmt.Fprintf(fw, "#define CIDR4_FILTER\n")
if p.config.dyn4Enabled {
fmt.Fprintf(fw, "#define CIDR4_LPM_PREFILTER\n")
}
}
if p.config.fix6Enabled {
fmt.Fprintf(fw, "#define CIDR6_FILTER\n")
if p.config.dyn6Enabled {
fmt.Fprintf(fw, "#define CIDR6_LPM_PREFILTER\n")
}
}
} | [
"func",
"(",
"p",
"*",
"PreFilter",
")",
"WriteConfig",
"(",
"fw",
"io",
".",
"Writer",
")",
"{",
"p",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"maxHKeys",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"maxLKeys",
")",
"\n\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"path",
".",
"Base",
"(",
"p",
".",
"maps",
"[",
"prefixesV4Fix",
"]",
".",
"String",
"(",
")",
")",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"path",
".",
"Base",
"(",
"p",
".",
"maps",
"[",
"prefixesV4Dyn",
"]",
".",
"String",
"(",
")",
")",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"path",
".",
"Base",
"(",
"p",
".",
"maps",
"[",
"prefixesV6Fix",
"]",
".",
"String",
"(",
")",
")",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
",",
"path",
".",
"Base",
"(",
"p",
".",
"maps",
"[",
"prefixesV6Dyn",
"]",
".",
"String",
"(",
")",
")",
")",
"\n\n",
"if",
"p",
".",
"config",
".",
"fix4Enabled",
"{",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"p",
".",
"config",
".",
"dyn4Enabled",
"{",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"p",
".",
"config",
".",
"fix6Enabled",
"{",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"p",
".",
"config",
".",
"dyn6Enabled",
"{",
"fmt",
".",
"Fprintf",
"(",
"fw",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WriteConfig dumps the configuration for the corresponding header file | [
"WriteConfig",
"dumps",
"the",
"configuration",
"for",
"the",
"corresponding",
"header",
"file"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/prefilter/prefilter.go#L65-L89 |
163,490 | cilium/cilium | pkg/datapath/prefilter/prefilter.go | Dump | func (p *PreFilter) Dump(to []string) ([]string, int64) {
p.mutex.RLock()
defer p.mutex.RUnlock()
for i := prefixesV4Dyn; i < mapCount; i++ {
to = p.dumpOneMap(i, to)
}
return to, p.revision
} | go | func (p *PreFilter) Dump(to []string) ([]string, int64) {
p.mutex.RLock()
defer p.mutex.RUnlock()
for i := prefixesV4Dyn; i < mapCount; i++ {
to = p.dumpOneMap(i, to)
}
return to, p.revision
} | [
"func",
"(",
"p",
"*",
"PreFilter",
")",
"Dump",
"(",
"to",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"int64",
")",
"{",
"p",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"i",
":=",
"prefixesV4Dyn",
";",
"i",
"<",
"mapCount",
";",
"i",
"++",
"{",
"to",
"=",
"p",
".",
"dumpOneMap",
"(",
"i",
",",
"to",
")",
"\n",
"}",
"\n",
"return",
"to",
",",
"p",
".",
"revision",
"\n",
"}"
] | // Dump dumps revision and CIDRs as string slice of all participating maps | [
"Dump",
"dumps",
"revision",
"and",
"CIDRs",
"as",
"string",
"slice",
"of",
"all",
"participating",
"maps"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/prefilter/prefilter.go#L99-L106 |
163,491 | cilium/cilium | pkg/datapath/prefilter/prefilter.go | ProbePreFilter | func ProbePreFilter(device, mode string) error {
cmd := exec.Command("ip", "-force", "link", "set", "dev", device, mode, "off")
if err := cmd.Start(); err != nil {
return fmt.Errorf("Cannot run ip command: %v", err)
}
if err := cmd.Wait(); err != nil {
if exiterr, ok := err.(*exec.ExitError); ok {
if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
switch status.ExitStatus() {
case 2:
return fmt.Errorf("Mode %s not supported on device %s", mode, device)
default:
return fmt.Errorf("Prefilter not supported on OS")
}
}
} else {
return fmt.Errorf("Cannot wait for ip command: %v", err)
}
}
return nil
} | go | func ProbePreFilter(device, mode string) error {
cmd := exec.Command("ip", "-force", "link", "set", "dev", device, mode, "off")
if err := cmd.Start(); err != nil {
return fmt.Errorf("Cannot run ip command: %v", err)
}
if err := cmd.Wait(); err != nil {
if exiterr, ok := err.(*exec.ExitError); ok {
if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
switch status.ExitStatus() {
case 2:
return fmt.Errorf("Mode %s not supported on device %s", mode, device)
default:
return fmt.Errorf("Prefilter not supported on OS")
}
}
} else {
return fmt.Errorf("Cannot wait for ip command: %v", err)
}
}
return nil
} | [
"func",
"ProbePreFilter",
"(",
"device",
",",
"mode",
"string",
")",
"error",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"device",
",",
"mode",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"exiterr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"exec",
".",
"ExitError",
")",
";",
"ok",
"{",
"if",
"status",
",",
"ok",
":=",
"exiterr",
".",
"Sys",
"(",
")",
".",
"(",
"syscall",
".",
"WaitStatus",
")",
";",
"ok",
"{",
"switch",
"status",
".",
"ExitStatus",
"(",
")",
"{",
"case",
"2",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"mode",
",",
"device",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ProbePreFilter checks whether XDP mode is supported on given device | [
"ProbePreFilter",
"checks",
"whether",
"XDP",
"mode",
"is",
"supported",
"on",
"given",
"device"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/prefilter/prefilter.go#L258-L278 |
163,492 | cilium/cilium | pkg/datapath/prefilter/prefilter.go | NewPreFilter | func NewPreFilter() (*PreFilter, error) {
// dyn{4,6} officially disabled for now due to missing
// dump (get_next_key) from kernel side.
c := preFilterConfig{
dyn4Enabled: false,
dyn6Enabled: false,
fix4Enabled: true,
fix6Enabled: true,
}
p := &PreFilter{
revision: 1,
config: c,
}
// Only needed here given we access pinned maps.
p.mutex.Lock()
defer p.mutex.Unlock()
return p.init()
} | go | func NewPreFilter() (*PreFilter, error) {
// dyn{4,6} officially disabled for now due to missing
// dump (get_next_key) from kernel side.
c := preFilterConfig{
dyn4Enabled: false,
dyn6Enabled: false,
fix4Enabled: true,
fix6Enabled: true,
}
p := &PreFilter{
revision: 1,
config: c,
}
// Only needed here given we access pinned maps.
p.mutex.Lock()
defer p.mutex.Unlock()
return p.init()
} | [
"func",
"NewPreFilter",
"(",
")",
"(",
"*",
"PreFilter",
",",
"error",
")",
"{",
"// dyn{4,6} officially disabled for now due to missing",
"// dump (get_next_key) from kernel side.",
"c",
":=",
"preFilterConfig",
"{",
"dyn4Enabled",
":",
"false",
",",
"dyn6Enabled",
":",
"false",
",",
"fix4Enabled",
":",
"true",
",",
"fix6Enabled",
":",
"true",
",",
"}",
"\n",
"p",
":=",
"&",
"PreFilter",
"{",
"revision",
":",
"1",
",",
"config",
":",
"c",
",",
"}",
"\n",
"// Only needed here given we access pinned maps.",
"p",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"init",
"(",
")",
"\n",
"}"
] | // NewPreFilter returns prefilter handle | [
"NewPreFilter",
"returns",
"prefilter",
"handle"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/prefilter/prefilter.go#L281-L298 |
163,493 | cilium/cilium | pkg/monitor/datapath_debug.go | Dump | func (n *DebugMsg) Dump(prefix string) {
fmt.Printf("%s MARK %#x FROM %d DEBUG: %s\n", prefix, n.Hash, n.Source, n.subTypeString())
} | go | func (n *DebugMsg) Dump(prefix string) {
fmt.Printf("%s MARK %#x FROM %d DEBUG: %s\n", prefix, n.Hash, n.Source, n.subTypeString())
} | [
"func",
"(",
"n",
"*",
"DebugMsg",
")",
"Dump",
"(",
"prefix",
"string",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"prefix",
",",
"n",
".",
"Hash",
",",
"n",
".",
"Source",
",",
"n",
".",
"subTypeString",
"(",
")",
")",
"\n",
"}"
] | // Dump prints the debug message in a human readable format. | [
"Dump",
"prints",
"the",
"debug",
"message",
"in",
"a",
"human",
"readable",
"format",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_debug.go#L236-L238 |
163,494 | cilium/cilium | pkg/monitor/datapath_debug.go | DumpInfo | func (n *DebugCapture) DumpInfo(data []byte) {
prefix := n.infoPrefix()
if len(prefix) > 0 {
fmt.Printf("%s: %s\n", prefix, GetConnectionSummary(data[DebugCaptureLen:]))
}
} | go | func (n *DebugCapture) DumpInfo(data []byte) {
prefix := n.infoPrefix()
if len(prefix) > 0 {
fmt.Printf("%s: %s\n", prefix, GetConnectionSummary(data[DebugCaptureLen:]))
}
} | [
"func",
"(",
"n",
"*",
"DebugCapture",
")",
"DumpInfo",
"(",
"data",
"[",
"]",
"byte",
")",
"{",
"prefix",
":=",
"n",
".",
"infoPrefix",
"(",
")",
"\n\n",
"if",
"len",
"(",
"prefix",
")",
">",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"prefix",
",",
"GetConnectionSummary",
"(",
"data",
"[",
"DebugCaptureLen",
":",
"]",
")",
")",
"\n",
"}",
"\n",
"}"
] | // DumpInfo prints a summary of the capture messages. | [
"DumpInfo",
"prints",
"a",
"summary",
"of",
"the",
"capture",
"messages",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_debug.go#L398-L404 |
163,495 | cilium/cilium | pkg/monitor/datapath_debug.go | DumpVerbose | func (n *DebugCapture) DumpVerbose(dissect bool, data []byte, prefix string) {
fmt.Printf("%s MARK %#x FROM %d DEBUG: %d bytes, ", prefix, n.Hash, n.Source, n.Len)
fmt.Println(n.subTypeString())
if n.Len > 0 && len(data) > DebugCaptureLen {
Dissect(dissect, data[DebugCaptureLen:])
}
} | go | func (n *DebugCapture) DumpVerbose(dissect bool, data []byte, prefix string) {
fmt.Printf("%s MARK %#x FROM %d DEBUG: %d bytes, ", prefix, n.Hash, n.Source, n.Len)
fmt.Println(n.subTypeString())
if n.Len > 0 && len(data) > DebugCaptureLen {
Dissect(dissect, data[DebugCaptureLen:])
}
} | [
"func",
"(",
"n",
"*",
"DebugCapture",
")",
"DumpVerbose",
"(",
"dissect",
"bool",
",",
"data",
"[",
"]",
"byte",
",",
"prefix",
"string",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"prefix",
",",
"n",
".",
"Hash",
",",
"n",
".",
"Source",
",",
"n",
".",
"Len",
")",
"\n",
"fmt",
".",
"Println",
"(",
"n",
".",
"subTypeString",
"(",
")",
")",
"\n\n",
"if",
"n",
".",
"Len",
">",
"0",
"&&",
"len",
"(",
"data",
")",
">",
"DebugCaptureLen",
"{",
"Dissect",
"(",
"dissect",
",",
"data",
"[",
"DebugCaptureLen",
":",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // DumpVerbose prints the captured packet in human readable format | [
"DumpVerbose",
"prints",
"the",
"captured",
"packet",
"in",
"human",
"readable",
"format"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_debug.go#L428-L435 |
163,496 | cilium/cilium | pkg/monitor/datapath_debug.go | DebugCaptureToVerbose | func DebugCaptureToVerbose(n *DebugCapture) DebugCaptureVerbose {
return DebugCaptureVerbose{
Type: "capture",
Mark: fmt.Sprintf("%#x", n.Hash),
Source: n.Source,
Bytes: n.Len,
Message: n.subTypeString(),
Prefix: n.infoPrefix(),
}
} | go | func DebugCaptureToVerbose(n *DebugCapture) DebugCaptureVerbose {
return DebugCaptureVerbose{
Type: "capture",
Mark: fmt.Sprintf("%#x", n.Hash),
Source: n.Source,
Bytes: n.Len,
Message: n.subTypeString(),
Prefix: n.infoPrefix(),
}
} | [
"func",
"DebugCaptureToVerbose",
"(",
"n",
"*",
"DebugCapture",
")",
"DebugCaptureVerbose",
"{",
"return",
"DebugCaptureVerbose",
"{",
"Type",
":",
"\"",
"\"",
",",
"Mark",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"n",
".",
"Hash",
")",
",",
"Source",
":",
"n",
".",
"Source",
",",
"Bytes",
":",
"n",
".",
"Len",
",",
"Message",
":",
"n",
".",
"subTypeString",
"(",
")",
",",
"Prefix",
":",
"n",
".",
"infoPrefix",
"(",
")",
",",
"}",
"\n",
"}"
] | // DebugCaptureToVerbose creates verbose notification from base TraceNotify | [
"DebugCaptureToVerbose",
"creates",
"verbose",
"notification",
"from",
"base",
"TraceNotify"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/datapath_debug.go#L495-L504 |
163,497 | cilium/cilium | daemon/ipam.go | DumpIPAM | func (d *Daemon) DumpIPAM() *models.IPAMStatus {
allocv4, allocv6 := d.ipam.Dump()
status := &models.IPAMStatus{}
v4 := []string{}
for ip := range allocv4 {
v4 = append(v4, ip)
}
v6 := []string{}
for ip, owner := range allocv6 {
v6 = append(v6, ip)
// merge allocv6 into allocv4
allocv4[ip] = owner
}
if option.Config.EnableIPv4 {
status.IPV4 = v4
}
if option.Config.EnableIPv6 {
status.IPV6 = v4
}
status.Allocations = allocv4
return status
} | go | func (d *Daemon) DumpIPAM() *models.IPAMStatus {
allocv4, allocv6 := d.ipam.Dump()
status := &models.IPAMStatus{}
v4 := []string{}
for ip := range allocv4 {
v4 = append(v4, ip)
}
v6 := []string{}
for ip, owner := range allocv6 {
v6 = append(v6, ip)
// merge allocv6 into allocv4
allocv4[ip] = owner
}
if option.Config.EnableIPv4 {
status.IPV4 = v4
}
if option.Config.EnableIPv6 {
status.IPV6 = v4
}
status.Allocations = allocv4
return status
} | [
"func",
"(",
"d",
"*",
"Daemon",
")",
"DumpIPAM",
"(",
")",
"*",
"models",
".",
"IPAMStatus",
"{",
"allocv4",
",",
"allocv6",
":=",
"d",
".",
"ipam",
".",
"Dump",
"(",
")",
"\n",
"status",
":=",
"&",
"models",
".",
"IPAMStatus",
"{",
"}",
"\n\n",
"v4",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"ip",
":=",
"range",
"allocv4",
"{",
"v4",
"=",
"append",
"(",
"v4",
",",
"ip",
")",
"\n",
"}",
"\n\n",
"v6",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"ip",
",",
"owner",
":=",
"range",
"allocv6",
"{",
"v6",
"=",
"append",
"(",
"v6",
",",
"ip",
")",
"\n",
"// merge allocv6 into allocv4",
"allocv4",
"[",
"ip",
"]",
"=",
"owner",
"\n",
"}",
"\n\n",
"if",
"option",
".",
"Config",
".",
"EnableIPv4",
"{",
"status",
".",
"IPV4",
"=",
"v4",
"\n",
"}",
"\n\n",
"if",
"option",
".",
"Config",
".",
"EnableIPv6",
"{",
"status",
".",
"IPV6",
"=",
"v4",
"\n",
"}",
"\n\n",
"status",
".",
"Allocations",
"=",
"allocv4",
"\n\n",
"return",
"status",
"\n",
"}"
] | // DumpIPAM dumps in the form of a map, the list of
// reserved IPv4 and IPv6 addresses. | [
"DumpIPAM",
"dumps",
"in",
"the",
"form",
"of",
"a",
"map",
"the",
"list",
"of",
"reserved",
"IPv4",
"and",
"IPv6",
"addresses",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/daemon/ipam.go#L104-L131 |
163,498 | cilium/cilium | pkg/proxy/logger/epinfo.go | getEndpointInfo | func getEndpointInfo(source EndpointInfoSource) *accesslog.EndpointInfo {
source.UnconditionalRLock()
defer source.RUnlock()
return &accesslog.EndpointInfo{
ID: source.GetID(),
IPv4: source.GetIPv4Address(),
IPv6: source.GetIPv6Address(),
Labels: source.GetLabels(),
LabelsSHA256: source.GetLabelsSHA(),
Identity: uint64(source.GetIdentity()),
}
} | go | func getEndpointInfo(source EndpointInfoSource) *accesslog.EndpointInfo {
source.UnconditionalRLock()
defer source.RUnlock()
return &accesslog.EndpointInfo{
ID: source.GetID(),
IPv4: source.GetIPv4Address(),
IPv6: source.GetIPv6Address(),
Labels: source.GetLabels(),
LabelsSHA256: source.GetLabelsSHA(),
Identity: uint64(source.GetIdentity()),
}
} | [
"func",
"getEndpointInfo",
"(",
"source",
"EndpointInfoSource",
")",
"*",
"accesslog",
".",
"EndpointInfo",
"{",
"source",
".",
"UnconditionalRLock",
"(",
")",
"\n",
"defer",
"source",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"&",
"accesslog",
".",
"EndpointInfo",
"{",
"ID",
":",
"source",
".",
"GetID",
"(",
")",
",",
"IPv4",
":",
"source",
".",
"GetIPv4Address",
"(",
")",
",",
"IPv6",
":",
"source",
".",
"GetIPv6Address",
"(",
")",
",",
"Labels",
":",
"source",
".",
"GetLabels",
"(",
")",
",",
"LabelsSHA256",
":",
"source",
".",
"GetLabelsSHA",
"(",
")",
",",
"Identity",
":",
"uint64",
"(",
"source",
".",
"GetIdentity",
"(",
")",
")",
",",
"}",
"\n",
"}"
] | // getEndpointInfo returns a consistent snapshot of the given source.
// The source's read lock must not be held. | [
"getEndpointInfo",
"returns",
"a",
"consistent",
"snapshot",
"of",
"the",
"given",
"source",
".",
"The",
"source",
"s",
"read",
"lock",
"must",
"not",
"be",
"held",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/proxy/logger/epinfo.go#L41-L52 |
163,499 | cilium/cilium | pkg/policy/mapstate.go | DetermineAllowLocalhost | func (keys MapState) DetermineAllowLocalhost(l4Policy *L4Policy) {
if option.Config.AlwaysAllowLocalhost() || (l4Policy != nil && l4Policy.HasRedirect()) {
keys[localHostKey] = MapStateEntry{}
}
} | go | func (keys MapState) DetermineAllowLocalhost(l4Policy *L4Policy) {
if option.Config.AlwaysAllowLocalhost() || (l4Policy != nil && l4Policy.HasRedirect()) {
keys[localHostKey] = MapStateEntry{}
}
} | [
"func",
"(",
"keys",
"MapState",
")",
"DetermineAllowLocalhost",
"(",
"l4Policy",
"*",
"L4Policy",
")",
"{",
"if",
"option",
".",
"Config",
".",
"AlwaysAllowLocalhost",
"(",
")",
"||",
"(",
"l4Policy",
"!=",
"nil",
"&&",
"l4Policy",
".",
"HasRedirect",
"(",
")",
")",
"{",
"keys",
"[",
"localHostKey",
"]",
"=",
"MapStateEntry",
"{",
"}",
"\n",
"}",
"\n",
"}"
] | // DetermineAllowLocalhost determines whether communication should be allowed to
// the localhost. It inserts the Key corresponding to the localhost in
// the desiredPolicyKeys if the endpoint is allowed to communicate with the
// localhost. | [
"DetermineAllowLocalhost",
"determines",
"whether",
"communication",
"should",
"be",
"allowed",
"to",
"the",
"localhost",
".",
"It",
"inserts",
"the",
"Key",
"corresponding",
"to",
"the",
"localhost",
"in",
"the",
"desiredPolicyKeys",
"if",
"the",
"endpoint",
"is",
"allowed",
"to",
"communicate",
"with",
"the",
"localhost",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/mapstate.go#L80-L85 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.