id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
162,400 |
cilium/cilium
|
pkg/datapath/maps/map.go
|
CollectStaleMapGarbage
|
func CollectStaleMapGarbage() {
if err := filepath.Walk(bpf.MapPrefixPath(), globalSweeper.walk); err != nil {
log.WithError(err).Warn("Error while scanning for stale maps")
}
}
|
go
|
func CollectStaleMapGarbage() {
if err := filepath.Walk(bpf.MapPrefixPath(), globalSweeper.walk); err != nil {
log.WithError(err).Warn("Error while scanning for stale maps")
}
}
|
[
"func",
"CollectStaleMapGarbage",
"(",
")",
"{",
"if",
"err",
":=",
"filepath",
".",
"Walk",
"(",
"bpf",
".",
"MapPrefixPath",
"(",
")",
",",
"globalSweeper",
".",
"walk",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// CollectStaleMapGarbage cleans up stale content in the BPF maps from the
// datapath.
|
[
"CollectStaleMapGarbage",
"cleans",
"up",
"stale",
"content",
"in",
"the",
"BPF",
"maps",
"from",
"the",
"datapath",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/maps/map.go#L153-L157
|
162,401 |
cilium/cilium
|
pkg/datapath/maps/map.go
|
RemoveDisabledMaps
|
func RemoveDisabledMaps() {
maps := []string{}
if !option.Config.EnableIPv6 {
maps = append(maps, []string{
"cilium_ct6_global",
"cilium_ct_any6_global",
"cilium_lb6_reverse_nat",
"cilium_lb6_rr_seq",
"cilium_lb6_services",
"cilium_snat_v6_external",
"cilium_proxy6"}...)
}
if !option.Config.EnableIPv4 {
maps = append(maps, []string{
"cilium_ct4_global",
"cilium_ct_any4_global",
"cilium_lb4_reverse_nat",
"cilium_lb4_rr_seq",
"cilium_lb4_services",
"cilium_snat_v4_external",
"cilium_proxy4"}...)
}
for _, m := range maps {
p := path.Join(bpf.MapPrefixPath(), m)
if _, err := os.Stat(p); !os.IsNotExist(err) {
globalSweeper.removeMapPath(p)
}
}
}
|
go
|
func RemoveDisabledMaps() {
maps := []string{}
if !option.Config.EnableIPv6 {
maps = append(maps, []string{
"cilium_ct6_global",
"cilium_ct_any6_global",
"cilium_lb6_reverse_nat",
"cilium_lb6_rr_seq",
"cilium_lb6_services",
"cilium_snat_v6_external",
"cilium_proxy6"}...)
}
if !option.Config.EnableIPv4 {
maps = append(maps, []string{
"cilium_ct4_global",
"cilium_ct_any4_global",
"cilium_lb4_reverse_nat",
"cilium_lb4_rr_seq",
"cilium_lb4_services",
"cilium_snat_v4_external",
"cilium_proxy4"}...)
}
for _, m := range maps {
p := path.Join(bpf.MapPrefixPath(), m)
if _, err := os.Stat(p); !os.IsNotExist(err) {
globalSweeper.removeMapPath(p)
}
}
}
|
[
"func",
"RemoveDisabledMaps",
"(",
")",
"{",
"maps",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"if",
"!",
"option",
".",
"Config",
".",
"EnableIPv6",
"{",
"maps",
"=",
"append",
"(",
"maps",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"option",
".",
"Config",
".",
"EnableIPv4",
"{",
"maps",
"=",
"append",
"(",
"maps",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"...",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"m",
":=",
"range",
"maps",
"{",
"p",
":=",
"path",
".",
"Join",
"(",
"bpf",
".",
"MapPrefixPath",
"(",
")",
",",
"m",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"p",
")",
";",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"globalSweeper",
".",
"removeMapPath",
"(",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// RemoveDisabledMaps removes BPF maps in the filesystem for features that have
// been disabled. The maps may still be in use in which case they will continue
// to live until the BPF program using them is being replaced.
|
[
"RemoveDisabledMaps",
"removes",
"BPF",
"maps",
"in",
"the",
"filesystem",
"for",
"features",
"that",
"have",
"been",
"disabled",
".",
"The",
"maps",
"may",
"still",
"be",
"in",
"use",
"in",
"which",
"case",
"they",
"will",
"continue",
"to",
"live",
"until",
"the",
"BPF",
"program",
"using",
"them",
"is",
"being",
"replaced",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/maps/map.go#L162-L193
|
162,402 |
cilium/cilium
|
api/v1/server/restapi/policy/get_identity_endpoints_responses.go
|
WithPayload
|
func (o *GetIdentityEndpointsOK) WithPayload(payload []*models.IdentityEndpoints) *GetIdentityEndpointsOK {
o.Payload = payload
return o
}
|
go
|
func (o *GetIdentityEndpointsOK) WithPayload(payload []*models.IdentityEndpoints) *GetIdentityEndpointsOK {
o.Payload = payload
return o
}
|
[
"func",
"(",
"o",
"*",
"GetIdentityEndpointsOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"IdentityEndpoints",
")",
"*",
"GetIdentityEndpointsOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithPayload adds the payload to the get identity endpoints o k response
|
[
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"identity",
"endpoints",
"o",
"k",
"response"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity_endpoints_responses.go#L38-L41
|
162,403 |
cilium/cilium
|
pkg/datapath/linux/linux_defaults/mark.go
|
GetMagicProxyMark
|
func GetMagicProxyMark(isIngress bool, identity int) int {
var mark int
if isIngress {
mark = MagicMarkIngress
} else {
mark = MagicMarkEgress
}
if identity != 0 {
mark |= (identity >> 16) & 0xFF
mark |= (identity & 0xFFFF) << 16
}
return mark
}
|
go
|
func GetMagicProxyMark(isIngress bool, identity int) int {
var mark int
if isIngress {
mark = MagicMarkIngress
} else {
mark = MagicMarkEgress
}
if identity != 0 {
mark |= (identity >> 16) & 0xFF
mark |= (identity & 0xFFFF) << 16
}
return mark
}
|
[
"func",
"GetMagicProxyMark",
"(",
"isIngress",
"bool",
",",
"identity",
"int",
")",
"int",
"{",
"var",
"mark",
"int",
"\n\n",
"if",
"isIngress",
"{",
"mark",
"=",
"MagicMarkIngress",
"\n",
"}",
"else",
"{",
"mark",
"=",
"MagicMarkEgress",
"\n",
"}",
"\n\n",
"if",
"identity",
"!=",
"0",
"{",
"mark",
"|=",
"(",
"identity",
">>",
"16",
")",
"&",
"0xFF",
"\n",
"mark",
"|=",
"(",
"identity",
"&",
"0xFFFF",
")",
"<<",
"16",
"\n",
"}",
"\n\n",
"return",
"mark",
"\n",
"}"
] |
// getMagicMark returns the magic marker with which each packet must be marked.
// The mark is different depending on whether the proxy is injected at ingress
// or egress.
|
[
"getMagicMark",
"returns",
"the",
"magic",
"marker",
"with",
"which",
"each",
"packet",
"must",
"be",
"marked",
".",
"The",
"mark",
"is",
"different",
"depending",
"on",
"whether",
"the",
"proxy",
"is",
"injected",
"at",
"ingress",
"or",
"egress",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/linux_defaults/mark.go#L86-L101
|
162,404 |
cilium/cilium
|
api/v1/models/controller_status.go
|
Validate
|
func (m *ControllerStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatus(formats); err != nil {
res = append(res, err)
}
if err := m.validateUUID(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
go
|
func (m *ControllerStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateStatus(formats); err != nil {
res = append(res, err)
}
if err := m.validateUUID(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"ControllerStatus",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateConfiguration",
"(",
"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",
"err",
":=",
"m",
".",
"validateUUID",
"(",
"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 controller status
|
[
"Validate",
"validates",
"this",
"controller",
"status"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/controller_status.go#L36-L55
|
162,405 |
cilium/cilium
|
pkg/datapath/linux/route/route.go
|
LogFields
|
func (r *Route) LogFields() logrus.Fields {
return logrus.Fields{
"prefix": r.Prefix,
"nexthop": r.Nexthop,
"local": r.Local,
logfields.Interface: r.Device,
}
}
|
go
|
func (r *Route) LogFields() logrus.Fields {
return logrus.Fields{
"prefix": r.Prefix,
"nexthop": r.Nexthop,
"local": r.Local,
logfields.Interface: r.Device,
}
}
|
[
"func",
"(",
"r",
"*",
"Route",
")",
"LogFields",
"(",
")",
"logrus",
".",
"Fields",
"{",
"return",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"r",
".",
"Prefix",
",",
"\"",
"\"",
":",
"r",
".",
"Nexthop",
",",
"\"",
"\"",
":",
"r",
".",
"Local",
",",
"logfields",
".",
"Interface",
":",
"r",
".",
"Device",
",",
"}",
"\n",
"}"
] |
// LogFields returns the route attributes as logrus.Fields map
|
[
"LogFields",
"returns",
"the",
"route",
"attributes",
"as",
"logrus",
".",
"Fields",
"map"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/route/route.go#L40-L47
|
162,406 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
progLDFlags
|
func progLDFlags(prog *progInfo, dir *directoryInfo) []string {
return []string{
fmt.Sprintf("-filetype=%s", prog.OutputType),
"-o", path.Join(dir.Output, prog.Output),
}
}
|
go
|
func progLDFlags(prog *progInfo, dir *directoryInfo) []string {
return []string{
fmt.Sprintf("-filetype=%s", prog.OutputType),
"-o", path.Join(dir.Output, prog.Output),
}
}
|
[
"func",
"progLDFlags",
"(",
"prog",
"*",
"progInfo",
",",
"dir",
"*",
"directoryInfo",
")",
"[",
"]",
"string",
"{",
"return",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prog",
".",
"OutputType",
")",
",",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"dir",
".",
"Output",
",",
"prog",
".",
"Output",
")",
",",
"}",
"\n",
"}"
] |
// progLDFlags determines the loader flags for the specified prog and paths.
|
[
"progLDFlags",
"determines",
"the",
"loader",
"flags",
"for",
"the",
"specified",
"prog",
"and",
"paths",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L109-L114
|
162,407 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
prepareCmdPipes
|
func prepareCmdPipes(cmd *exec.Cmd) (io.ReadCloser, io.ReadCloser, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, nil, fmt.Errorf("Failed to get stdout pipe: %s", err)
}
stderr, err := cmd.StderrPipe()
if err != nil {
stdout.Close()
return nil, nil, fmt.Errorf("Failed to get stderr pipe: %s", err)
}
return stdout, stderr, nil
}
|
go
|
func prepareCmdPipes(cmd *exec.Cmd) (io.ReadCloser, io.ReadCloser, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, nil, fmt.Errorf("Failed to get stdout pipe: %s", err)
}
stderr, err := cmd.StderrPipe()
if err != nil {
stdout.Close()
return nil, nil, fmt.Errorf("Failed to get stderr pipe: %s", err)
}
return stdout, stderr, nil
}
|
[
"func",
"prepareCmdPipes",
"(",
"cmd",
"*",
"exec",
".",
"Cmd",
")",
"(",
"io",
".",
"ReadCloser",
",",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"stdout",
",",
"err",
":=",
"cmd",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"stderr",
",",
"err",
":=",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"stdout",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"stdout",
",",
"stderr",
",",
"nil",
"\n",
"}"
] |
// prepareCmdPipes attaches pipes to the stdout and stderr of the specified
// command, and returns the stdout, stderr, and any error that may have
// occurred while creating the pipes.
|
[
"prepareCmdPipes",
"attaches",
"pipes",
"to",
"the",
"stdout",
"and",
"stderr",
"of",
"the",
"specified",
"command",
"and",
"returns",
"the",
"stdout",
"stderr",
"and",
"any",
"error",
"that",
"may",
"have",
"occurred",
"while",
"creating",
"the",
"pipes",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L119-L132
|
162,408 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
compileAndLink
|
func compileAndLink(ctx context.Context, prog *progInfo, dir *directoryInfo, debug bool, compileArgs ...string) error {
compileCmd, cancelCompile := exec.WithCancel(ctx, compiler, compileArgs...)
defer cancelCompile()
compilerStdout, compilerStderr, err := prepareCmdPipes(compileCmd)
if err != nil {
return err
}
linkArgs := make([]string, 0, 8)
if debug {
linkArgs = append(linkArgs, "-mattr=dwarfris")
}
linkArgs = append(linkArgs, standardLDFlags...)
linkArgs = append(linkArgs, progLDFlags(prog, dir)...)
linkCmd := exec.CommandContext(ctx, linker, linkArgs...)
linkCmd.Stdin = compilerStdout
if err := compileCmd.Start(); err != nil {
return fmt.Errorf("Failed to start command %s: %s", compileCmd.Args, err)
}
var compileOut []byte
/* Ignoring the output here because pkg/command/exec will log it. */
_, err = linkCmd.CombinedOutput(log, true)
if err == nil {
compileOut, _ = ioutil.ReadAll(compilerStderr)
err = compileCmd.Wait()
} else {
cancelCompile()
}
if err != nil {
err = fmt.Errorf("Failed to compile %s: %s", prog.Output, err)
log.WithFields(logrus.Fields{
"compiler-pid": pidFromProcess(compileCmd.Process),
"linker-pid": pidFromProcess(linkCmd.Process),
}).Error(err)
if compileOut != nil {
scopedLog := log.Warn
if debug {
scopedLog = log.Debug
}
scanner := bufio.NewScanner(bytes.NewReader(compileOut))
for scanner.Scan() {
scopedLog(scanner.Text())
}
}
}
return err
}
|
go
|
func compileAndLink(ctx context.Context, prog *progInfo, dir *directoryInfo, debug bool, compileArgs ...string) error {
compileCmd, cancelCompile := exec.WithCancel(ctx, compiler, compileArgs...)
defer cancelCompile()
compilerStdout, compilerStderr, err := prepareCmdPipes(compileCmd)
if err != nil {
return err
}
linkArgs := make([]string, 0, 8)
if debug {
linkArgs = append(linkArgs, "-mattr=dwarfris")
}
linkArgs = append(linkArgs, standardLDFlags...)
linkArgs = append(linkArgs, progLDFlags(prog, dir)...)
linkCmd := exec.CommandContext(ctx, linker, linkArgs...)
linkCmd.Stdin = compilerStdout
if err := compileCmd.Start(); err != nil {
return fmt.Errorf("Failed to start command %s: %s", compileCmd.Args, err)
}
var compileOut []byte
/* Ignoring the output here because pkg/command/exec will log it. */
_, err = linkCmd.CombinedOutput(log, true)
if err == nil {
compileOut, _ = ioutil.ReadAll(compilerStderr)
err = compileCmd.Wait()
} else {
cancelCompile()
}
if err != nil {
err = fmt.Errorf("Failed to compile %s: %s", prog.Output, err)
log.WithFields(logrus.Fields{
"compiler-pid": pidFromProcess(compileCmd.Process),
"linker-pid": pidFromProcess(linkCmd.Process),
}).Error(err)
if compileOut != nil {
scopedLog := log.Warn
if debug {
scopedLog = log.Debug
}
scanner := bufio.NewScanner(bytes.NewReader(compileOut))
for scanner.Scan() {
scopedLog(scanner.Text())
}
}
}
return err
}
|
[
"func",
"compileAndLink",
"(",
"ctx",
"context",
".",
"Context",
",",
"prog",
"*",
"progInfo",
",",
"dir",
"*",
"directoryInfo",
",",
"debug",
"bool",
",",
"compileArgs",
"...",
"string",
")",
"error",
"{",
"compileCmd",
",",
"cancelCompile",
":=",
"exec",
".",
"WithCancel",
"(",
"ctx",
",",
"compiler",
",",
"compileArgs",
"...",
")",
"\n",
"defer",
"cancelCompile",
"(",
")",
"\n",
"compilerStdout",
",",
"compilerStderr",
",",
"err",
":=",
"prepareCmdPipes",
"(",
"compileCmd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"linkArgs",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"8",
")",
"\n",
"if",
"debug",
"{",
"linkArgs",
"=",
"append",
"(",
"linkArgs",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"linkArgs",
"=",
"append",
"(",
"linkArgs",
",",
"standardLDFlags",
"...",
")",
"\n",
"linkArgs",
"=",
"append",
"(",
"linkArgs",
",",
"progLDFlags",
"(",
"prog",
",",
"dir",
")",
"...",
")",
"\n\n",
"linkCmd",
":=",
"exec",
".",
"CommandContext",
"(",
"ctx",
",",
"linker",
",",
"linkArgs",
"...",
")",
"\n",
"linkCmd",
".",
"Stdin",
"=",
"compilerStdout",
"\n",
"if",
"err",
":=",
"compileCmd",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"compileCmd",
".",
"Args",
",",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"compileOut",
"[",
"]",
"byte",
"\n",
"/* Ignoring the output here because pkg/command/exec will log it. */",
"_",
",",
"err",
"=",
"linkCmd",
".",
"CombinedOutput",
"(",
"log",
",",
"true",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"compileOut",
",",
"_",
"=",
"ioutil",
".",
"ReadAll",
"(",
"compilerStderr",
")",
"\n",
"err",
"=",
"compileCmd",
".",
"Wait",
"(",
")",
"\n",
"}",
"else",
"{",
"cancelCompile",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"prog",
".",
"Output",
",",
"err",
")",
"\n",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"pidFromProcess",
"(",
"compileCmd",
".",
"Process",
")",
",",
"\"",
"\"",
":",
"pidFromProcess",
"(",
"linkCmd",
".",
"Process",
")",
",",
"}",
")",
".",
"Error",
"(",
"err",
")",
"\n",
"if",
"compileOut",
"!=",
"nil",
"{",
"scopedLog",
":=",
"log",
".",
"Warn",
"\n",
"if",
"debug",
"{",
"scopedLog",
"=",
"log",
".",
"Debug",
"\n",
"}",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"bytes",
".",
"NewReader",
"(",
"compileOut",
")",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"scopedLog",
"(",
"scanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] |
// compileAndLink links the specified program from the specified path to the
// intermediate representation, to the output specified in the prog's info.
|
[
"compileAndLink",
"links",
"the",
"specified",
"program",
"from",
"the",
"specified",
"path",
"to",
"the",
"intermediate",
"representation",
"to",
"the",
"output",
"specified",
"in",
"the",
"prog",
"s",
"info",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L144-L193
|
162,409 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
progCFlags
|
func progCFlags(prog *progInfo, dir *directoryInfo) []string {
var output string
if prog.OutputType == outputSource {
output = path.Join(dir.Output, prog.Output)
} else {
output = "-" // stdout
}
return append(testIncludes,
fmt.Sprintf("-I%s", path.Join(dir.Runtime, "globals")),
fmt.Sprintf("-I%s", dir.State),
fmt.Sprintf("-I%s", dir.Library),
fmt.Sprintf("-I%s", path.Join(dir.Library, "include")),
"-c", path.Join(dir.Library, prog.Source),
"-o", output,
)
}
|
go
|
func progCFlags(prog *progInfo, dir *directoryInfo) []string {
var output string
if prog.OutputType == outputSource {
output = path.Join(dir.Output, prog.Output)
} else {
output = "-" // stdout
}
return append(testIncludes,
fmt.Sprintf("-I%s", path.Join(dir.Runtime, "globals")),
fmt.Sprintf("-I%s", dir.State),
fmt.Sprintf("-I%s", dir.Library),
fmt.Sprintf("-I%s", path.Join(dir.Library, "include")),
"-c", path.Join(dir.Library, prog.Source),
"-o", output,
)
}
|
[
"func",
"progCFlags",
"(",
"prog",
"*",
"progInfo",
",",
"dir",
"*",
"directoryInfo",
")",
"[",
"]",
"string",
"{",
"var",
"output",
"string",
"\n\n",
"if",
"prog",
".",
"OutputType",
"==",
"outputSource",
"{",
"output",
"=",
"path",
".",
"Join",
"(",
"dir",
".",
"Output",
",",
"prog",
".",
"Output",
")",
"\n",
"}",
"else",
"{",
"output",
"=",
"\"",
"\"",
"// stdout",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"testIncludes",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"dir",
".",
"Runtime",
",",
"\"",
"\"",
")",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"dir",
".",
"State",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"dir",
".",
"Library",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"dir",
".",
"Library",
",",
"\"",
"\"",
")",
")",
",",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"dir",
".",
"Library",
",",
"prog",
".",
"Source",
")",
",",
"\"",
"\"",
",",
"output",
",",
")",
"\n",
"}"
] |
// progLDFlags determines the compiler flags for the specified prog and paths.
|
[
"progLDFlags",
"determines",
"the",
"compiler",
"flags",
"for",
"the",
"specified",
"prog",
"and",
"paths",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L196-L213
|
162,410 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
compile
|
func compile(ctx context.Context, prog *progInfo, dir *directoryInfo, debug bool) (err error) {
args := make([]string, 0, 16)
if prog.OutputType == outputSource {
args = append(args, "-E") // Preprocessor
} else {
args = append(args, "-emit-llvm")
if debug {
args = append(args, "-g")
}
}
args = append(args, standardCFlags...)
args = append(args, progCFlags(prog, dir)...)
// Compilation is split between two exec calls. First clang generates
// LLVM bitcode and then later llc compiles it to byte-code.
log.WithFields(logrus.Fields{
"target": compiler,
"args": args,
}).Debug("Launching compiler")
if prog.OutputType == outputSource {
compileCmd := exec.CommandContext(ctx, compiler, args...)
_, err = compileCmd.CombinedOutput(log, debug)
} else {
switch prog.OutputType {
case outputObject:
err = compileAndLink(ctx, prog, dir, debug, args...)
case outputAssembly:
err = compileAndLink(ctx, prog, dir, false, args...)
default:
log.Fatalf("Unhandled progInfo.OutputType %s", prog.OutputType)
}
}
return err
}
|
go
|
func compile(ctx context.Context, prog *progInfo, dir *directoryInfo, debug bool) (err error) {
args := make([]string, 0, 16)
if prog.OutputType == outputSource {
args = append(args, "-E") // Preprocessor
} else {
args = append(args, "-emit-llvm")
if debug {
args = append(args, "-g")
}
}
args = append(args, standardCFlags...)
args = append(args, progCFlags(prog, dir)...)
// Compilation is split between two exec calls. First clang generates
// LLVM bitcode and then later llc compiles it to byte-code.
log.WithFields(logrus.Fields{
"target": compiler,
"args": args,
}).Debug("Launching compiler")
if prog.OutputType == outputSource {
compileCmd := exec.CommandContext(ctx, compiler, args...)
_, err = compileCmd.CombinedOutput(log, debug)
} else {
switch prog.OutputType {
case outputObject:
err = compileAndLink(ctx, prog, dir, debug, args...)
case outputAssembly:
err = compileAndLink(ctx, prog, dir, false, args...)
default:
log.Fatalf("Unhandled progInfo.OutputType %s", prog.OutputType)
}
}
return err
}
|
[
"func",
"compile",
"(",
"ctx",
"context",
".",
"Context",
",",
"prog",
"*",
"progInfo",
",",
"dir",
"*",
"directoryInfo",
",",
"debug",
"bool",
")",
"(",
"err",
"error",
")",
"{",
"args",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"16",
")",
"\n",
"if",
"prog",
".",
"OutputType",
"==",
"outputSource",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"// Preprocessor",
"\n",
"}",
"else",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"if",
"debug",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"standardCFlags",
"...",
")",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"progCFlags",
"(",
"prog",
",",
"dir",
")",
"...",
")",
"\n\n",
"// Compilation is split between two exec calls. First clang generates",
"// LLVM bitcode and then later llc compiles it to byte-code.",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"compiler",
",",
"\"",
"\"",
":",
"args",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"prog",
".",
"OutputType",
"==",
"outputSource",
"{",
"compileCmd",
":=",
"exec",
".",
"CommandContext",
"(",
"ctx",
",",
"compiler",
",",
"args",
"...",
")",
"\n",
"_",
",",
"err",
"=",
"compileCmd",
".",
"CombinedOutput",
"(",
"log",
",",
"debug",
")",
"\n",
"}",
"else",
"{",
"switch",
"prog",
".",
"OutputType",
"{",
"case",
"outputObject",
":",
"err",
"=",
"compileAndLink",
"(",
"ctx",
",",
"prog",
",",
"dir",
",",
"debug",
",",
"args",
"...",
")",
"\n",
"case",
"outputAssembly",
":",
"err",
"=",
"compileAndLink",
"(",
"ctx",
",",
"prog",
",",
"dir",
",",
"false",
",",
"args",
"...",
")",
"\n",
"default",
":",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"prog",
".",
"OutputType",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] |
// compile and link a program.
|
[
"compile",
"and",
"link",
"a",
"program",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L216-L250
|
162,411 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
Compile
|
func Compile(ctx context.Context, src string, out string) error {
debug := option.Config.BPFCompilationDebug
prog := progInfo{
Source: src,
Output: out,
OutputType: outputObject,
}
dirs := directoryInfo{
Library: option.Config.BpfDir,
Runtime: option.Config.StateDir,
Output: option.Config.StateDir,
State: option.Config.StateDir,
}
return compile(ctx, &prog, &dirs, debug)
}
|
go
|
func Compile(ctx context.Context, src string, out string) error {
debug := option.Config.BPFCompilationDebug
prog := progInfo{
Source: src,
Output: out,
OutputType: outputObject,
}
dirs := directoryInfo{
Library: option.Config.BpfDir,
Runtime: option.Config.StateDir,
Output: option.Config.StateDir,
State: option.Config.StateDir,
}
return compile(ctx, &prog, &dirs, debug)
}
|
[
"func",
"Compile",
"(",
"ctx",
"context",
".",
"Context",
",",
"src",
"string",
",",
"out",
"string",
")",
"error",
"{",
"debug",
":=",
"option",
".",
"Config",
".",
"BPFCompilationDebug",
"\n",
"prog",
":=",
"progInfo",
"{",
"Source",
":",
"src",
",",
"Output",
":",
"out",
",",
"OutputType",
":",
"outputObject",
",",
"}",
"\n",
"dirs",
":=",
"directoryInfo",
"{",
"Library",
":",
"option",
".",
"Config",
".",
"BpfDir",
",",
"Runtime",
":",
"option",
".",
"Config",
".",
"StateDir",
",",
"Output",
":",
"option",
".",
"Config",
".",
"StateDir",
",",
"State",
":",
"option",
".",
"Config",
".",
"StateDir",
",",
"}",
"\n",
"return",
"compile",
"(",
"ctx",
",",
"&",
"prog",
",",
"&",
"dirs",
",",
"debug",
")",
"\n",
"}"
] |
// Compile compiles a BPF program generating an object file.
|
[
"Compile",
"compiles",
"a",
"BPF",
"program",
"generating",
"an",
"object",
"file",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L295-L309
|
162,412 |
cilium/cilium
|
pkg/datapath/loader/compile.go
|
compileTemplate
|
func compileTemplate(ctx context.Context, out string) error {
dirs := directoryInfo{
Library: option.Config.BpfDir,
Runtime: option.Config.StateDir,
Output: out,
State: out,
}
return compileDatapath(ctx, &dirs, option.Config.BPFCompilationDebug, log)
}
|
go
|
func compileTemplate(ctx context.Context, out string) error {
dirs := directoryInfo{
Library: option.Config.BpfDir,
Runtime: option.Config.StateDir,
Output: out,
State: out,
}
return compileDatapath(ctx, &dirs, option.Config.BPFCompilationDebug, log)
}
|
[
"func",
"compileTemplate",
"(",
"ctx",
"context",
".",
"Context",
",",
"out",
"string",
")",
"error",
"{",
"dirs",
":=",
"directoryInfo",
"{",
"Library",
":",
"option",
".",
"Config",
".",
"BpfDir",
",",
"Runtime",
":",
"option",
".",
"Config",
".",
"StateDir",
",",
"Output",
":",
"out",
",",
"State",
":",
"out",
",",
"}",
"\n",
"return",
"compileDatapath",
"(",
"ctx",
",",
"&",
"dirs",
",",
"option",
".",
"Config",
".",
"BPFCompilationDebug",
",",
"log",
")",
"\n",
"}"
] |
// compileTemplate compiles a BPF program generating a template object file.
|
[
"compileTemplate",
"compiles",
"a",
"BPF",
"program",
"generating",
"a",
"template",
"object",
"file",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/loader/compile.go#L312-L320
|
162,413 |
cilium/cilium
|
pkg/envoy/xds/set.go
|
AddResourceVersionObserver
|
func (s *BaseObservableResourceSource) AddResourceVersionObserver(observer ResourceVersionObserver) {
s.locker.Lock()
defer s.locker.Unlock()
s.observers[observer] = struct{}{}
}
|
go
|
func (s *BaseObservableResourceSource) AddResourceVersionObserver(observer ResourceVersionObserver) {
s.locker.Lock()
defer s.locker.Unlock()
s.observers[observer] = struct{}{}
}
|
[
"func",
"(",
"s",
"*",
"BaseObservableResourceSource",
")",
"AddResourceVersionObserver",
"(",
"observer",
"ResourceVersionObserver",
")",
"{",
"s",
".",
"locker",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"locker",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"observers",
"[",
"observer",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}"
] |
// AddResourceVersionObserver registers an observer to be notified of new
// resource version.
|
[
"AddResourceVersionObserver",
"registers",
"an",
"observer",
"to",
"be",
"notified",
"of",
"new",
"resource",
"version",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/set.go#L164-L169
|
162,414 |
cilium/cilium
|
pkg/envoy/xds/set.go
|
RemoveResourceVersionObserver
|
func (s *BaseObservableResourceSource) RemoveResourceVersionObserver(observer ResourceVersionObserver) {
s.locker.Lock()
defer s.locker.Unlock()
delete(s.observers, observer)
}
|
go
|
func (s *BaseObservableResourceSource) RemoveResourceVersionObserver(observer ResourceVersionObserver) {
s.locker.Lock()
defer s.locker.Unlock()
delete(s.observers, observer)
}
|
[
"func",
"(",
"s",
"*",
"BaseObservableResourceSource",
")",
"RemoveResourceVersionObserver",
"(",
"observer",
"ResourceVersionObserver",
")",
"{",
"s",
".",
"locker",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"locker",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"s",
".",
"observers",
",",
"observer",
")",
"\n",
"}"
] |
// RemoveResourceVersionObserver unregisters an observer that was previously
// registered by calling AddResourceVersionObserver.
|
[
"RemoveResourceVersionObserver",
"unregisters",
"an",
"observer",
"that",
"was",
"previously",
"registered",
"by",
"calling",
"AddResourceVersionObserver",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/set.go#L173-L178
|
162,415 |
cilium/cilium
|
pkg/envoy/xds/set.go
|
NotifyNewResourceVersionRLocked
|
func (s *BaseObservableResourceSource) NotifyNewResourceVersionRLocked(typeURL string, version uint64) {
for o := range s.observers {
o.HandleNewResourceVersion(typeURL, version)
}
}
|
go
|
func (s *BaseObservableResourceSource) NotifyNewResourceVersionRLocked(typeURL string, version uint64) {
for o := range s.observers {
o.HandleNewResourceVersion(typeURL, version)
}
}
|
[
"func",
"(",
"s",
"*",
"BaseObservableResourceSource",
")",
"NotifyNewResourceVersionRLocked",
"(",
"typeURL",
"string",
",",
"version",
"uint64",
")",
"{",
"for",
"o",
":=",
"range",
"s",
".",
"observers",
"{",
"o",
".",
"HandleNewResourceVersion",
"(",
"typeURL",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] |
// NotifyNewResourceVersionRLocked notifies registered observers that a new version of
// the resources of the given type is available.
// This function MUST be called with locker's lock acquired.
|
[
"NotifyNewResourceVersionRLocked",
"notifies",
"registered",
"observers",
"that",
"a",
"new",
"version",
"of",
"the",
"resources",
"of",
"the",
"given",
"type",
"is",
"available",
".",
"This",
"function",
"MUST",
"be",
"called",
"with",
"locker",
"s",
"lock",
"acquired",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/set.go#L183-L187
|
162,416 |
cilium/cilium
|
api/v1/models/trace_to.go
|
Validate
|
func (m *TraceTo) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateDports(formats); err != nil {
res = append(res, err)
}
if err := m.validateLabels(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
go
|
func (m *TraceTo) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateDports(formats); err != nil {
res = append(res, err)
}
if err := m.validateLabels(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"TraceTo",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateDports",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateLabels",
"(",
"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 trace to
|
[
"Validate",
"validates",
"this",
"trace",
"to"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/trace_to.go#L31-L46
|
162,417 |
cilium/cilium
|
api/v1/client/service/delete_service_id_parameters.go
|
WithTimeout
|
func (o *DeleteServiceIDParams) WithTimeout(timeout time.Duration) *DeleteServiceIDParams {
o.SetTimeout(timeout)
return o
}
|
go
|
func (o *DeleteServiceIDParams) WithTimeout(timeout time.Duration) *DeleteServiceIDParams {
o.SetTimeout(timeout)
return o
}
|
[
"func",
"(",
"o",
"*",
"DeleteServiceIDParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"DeleteServiceIDParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithTimeout adds the timeout to the delete service ID params
|
[
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"delete",
"service",
"ID",
"params"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/delete_service_id_parameters.go#L77-L80
|
162,418 |
cilium/cilium
|
api/v1/client/service/delete_service_id_parameters.go
|
WithContext
|
func (o *DeleteServiceIDParams) WithContext(ctx context.Context) *DeleteServiceIDParams {
o.SetContext(ctx)
return o
}
|
go
|
func (o *DeleteServiceIDParams) WithContext(ctx context.Context) *DeleteServiceIDParams {
o.SetContext(ctx)
return o
}
|
[
"func",
"(",
"o",
"*",
"DeleteServiceIDParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"DeleteServiceIDParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithContext adds the context to the delete service ID params
|
[
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"delete",
"service",
"ID",
"params"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/delete_service_id_parameters.go#L88-L91
|
162,419 |
cilium/cilium
|
api/v1/client/service/delete_service_id_parameters.go
|
WithHTTPClient
|
func (o *DeleteServiceIDParams) WithHTTPClient(client *http.Client) *DeleteServiceIDParams {
o.SetHTTPClient(client)
return o
}
|
go
|
func (o *DeleteServiceIDParams) WithHTTPClient(client *http.Client) *DeleteServiceIDParams {
o.SetHTTPClient(client)
return o
}
|
[
"func",
"(",
"o",
"*",
"DeleteServiceIDParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"DeleteServiceIDParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithHTTPClient adds the HTTPClient to the delete service ID params
|
[
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"delete",
"service",
"ID",
"params"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/delete_service_id_parameters.go#L99-L102
|
162,420 |
cilium/cilium
|
api/v1/client/service/delete_service_id_parameters.go
|
WithID
|
func (o *DeleteServiceIDParams) WithID(id int64) *DeleteServiceIDParams {
o.SetID(id)
return o
}
|
go
|
func (o *DeleteServiceIDParams) WithID(id int64) *DeleteServiceIDParams {
o.SetID(id)
return o
}
|
[
"func",
"(",
"o",
"*",
"DeleteServiceIDParams",
")",
"WithID",
"(",
"id",
"int64",
")",
"*",
"DeleteServiceIDParams",
"{",
"o",
".",
"SetID",
"(",
"id",
")",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithID adds the id to the delete service ID params
|
[
"WithID",
"adds",
"the",
"id",
"to",
"the",
"delete",
"service",
"ID",
"params"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/delete_service_id_parameters.go#L110-L113
|
162,421 |
cilium/cilium
|
pkg/controller/manager.go
|
UpdateController
|
func (m *Manager) UpdateController(name string, params ControllerParams) *Controller {
start := time.Now()
// ensure the callbacks are valid
if params.DoFunc == nil {
params.DoFunc = func(ctx context.Context) error {
return undefinedDoFunc(name)
}
}
if params.StopFunc == nil {
params.StopFunc = NoopFunc
}
m.mutex.Lock()
if m.controllers == nil {
m.controllers = controllerMap{}
}
ctrl, exists := m.controllers[name]
if exists {
m.mutex.Unlock()
ctrl.getLogger().Debug("Updating existing controller")
ctrl.mutex.Lock()
ctrl.updateParamsLocked(params)
ctrl.mutex.Unlock()
// Notify the goroutine of the params update.
select {
case ctrl.update <- struct{}{}:
default:
}
ctrl.getLogger().Debug("Controller update time: ", time.Since(start))
} else {
ctrl = &Controller{
name: name,
uuid: uuid.NewUUID().String(),
stop: make(chan struct{}, 0),
update: make(chan struct{}, 1),
terminated: make(chan struct{}, 0),
}
ctrl.updateParamsLocked(params)
ctrl.getLogger().Debug("Starting new controller")
ctrl.ctxDoFunc, ctrl.cancelDoFunc = context.WithCancel(context.Background())
m.controllers[ctrl.name] = ctrl
m.mutex.Unlock()
globalStatus.mutex.Lock()
globalStatus.controllers[ctrl.uuid] = ctrl
globalStatus.mutex.Unlock()
go ctrl.runController()
}
return ctrl
}
|
go
|
func (m *Manager) UpdateController(name string, params ControllerParams) *Controller {
start := time.Now()
// ensure the callbacks are valid
if params.DoFunc == nil {
params.DoFunc = func(ctx context.Context) error {
return undefinedDoFunc(name)
}
}
if params.StopFunc == nil {
params.StopFunc = NoopFunc
}
m.mutex.Lock()
if m.controllers == nil {
m.controllers = controllerMap{}
}
ctrl, exists := m.controllers[name]
if exists {
m.mutex.Unlock()
ctrl.getLogger().Debug("Updating existing controller")
ctrl.mutex.Lock()
ctrl.updateParamsLocked(params)
ctrl.mutex.Unlock()
// Notify the goroutine of the params update.
select {
case ctrl.update <- struct{}{}:
default:
}
ctrl.getLogger().Debug("Controller update time: ", time.Since(start))
} else {
ctrl = &Controller{
name: name,
uuid: uuid.NewUUID().String(),
stop: make(chan struct{}, 0),
update: make(chan struct{}, 1),
terminated: make(chan struct{}, 0),
}
ctrl.updateParamsLocked(params)
ctrl.getLogger().Debug("Starting new controller")
ctrl.ctxDoFunc, ctrl.cancelDoFunc = context.WithCancel(context.Background())
m.controllers[ctrl.name] = ctrl
m.mutex.Unlock()
globalStatus.mutex.Lock()
globalStatus.controllers[ctrl.uuid] = ctrl
globalStatus.mutex.Unlock()
go ctrl.runController()
}
return ctrl
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"UpdateController",
"(",
"name",
"string",
",",
"params",
"ControllerParams",
")",
"*",
"Controller",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"// ensure the callbacks are valid",
"if",
"params",
".",
"DoFunc",
"==",
"nil",
"{",
"params",
".",
"DoFunc",
"=",
"func",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"undefinedDoFunc",
"(",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"params",
".",
"StopFunc",
"==",
"nil",
"{",
"params",
".",
"StopFunc",
"=",
"NoopFunc",
"\n",
"}",
"\n\n",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n\n",
"if",
"m",
".",
"controllers",
"==",
"nil",
"{",
"m",
".",
"controllers",
"=",
"controllerMap",
"{",
"}",
"\n",
"}",
"\n\n",
"ctrl",
",",
"exists",
":=",
"m",
".",
"controllers",
"[",
"name",
"]",
"\n",
"if",
"exists",
"{",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"ctrl",
".",
"getLogger",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"ctrl",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"ctrl",
".",
"updateParamsLocked",
"(",
"params",
")",
"\n",
"ctrl",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// Notify the goroutine of the params update.",
"select",
"{",
"case",
"ctrl",
".",
"update",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"default",
":",
"}",
"\n\n",
"ctrl",
".",
"getLogger",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"time",
".",
"Since",
"(",
"start",
")",
")",
"\n",
"}",
"else",
"{",
"ctrl",
"=",
"&",
"Controller",
"{",
"name",
":",
"name",
",",
"uuid",
":",
"uuid",
".",
"NewUUID",
"(",
")",
".",
"String",
"(",
")",
",",
"stop",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
",",
"update",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"terminated",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
",",
"}",
"\n",
"ctrl",
".",
"updateParamsLocked",
"(",
"params",
")",
"\n",
"ctrl",
".",
"getLogger",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"ctrl",
".",
"ctxDoFunc",
",",
"ctrl",
".",
"cancelDoFunc",
"=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"m",
".",
"controllers",
"[",
"ctrl",
".",
"name",
"]",
"=",
"ctrl",
"\n",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"globalStatus",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"globalStatus",
".",
"controllers",
"[",
"ctrl",
".",
"uuid",
"]",
"=",
"ctrl",
"\n",
"globalStatus",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"go",
"ctrl",
".",
"runController",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"ctrl",
"\n",
"}"
] |
// UpdateController installs or updates a controller in the manager. A
// controller is identified by its name. If a controller with the name already
// exists, the controller will be shut down and replaced with the provided
// controller. Updating a controller will cause the DoFunc to be run
// immediately regardless of any previous conditions. It will also cause any
// statistics to be reset.
|
[
"UpdateController",
"installs",
"or",
"updates",
"a",
"controller",
"in",
"the",
"manager",
".",
"A",
"controller",
"is",
"identified",
"by",
"its",
"name",
".",
"If",
"a",
"controller",
"with",
"the",
"name",
"already",
"exists",
"the",
"controller",
"will",
"be",
"shut",
"down",
"and",
"replaced",
"with",
"the",
"provided",
"controller",
".",
"Updating",
"a",
"controller",
"will",
"cause",
"the",
"DoFunc",
"to",
"be",
"run",
"immediately",
"regardless",
"of",
"any",
"previous",
"conditions",
".",
"It",
"will",
"also",
"cause",
"any",
"statistics",
"to",
"be",
"reset",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L58-L116
|
162,422 |
cilium/cilium
|
pkg/controller/manager.go
|
RemoveController
|
func (m *Manager) RemoveController(name string) error {
_, err := m.removeAndReturnController(name)
return err
}
|
go
|
func (m *Manager) RemoveController(name string) error {
_, err := m.removeAndReturnController(name)
return err
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"RemoveController",
"(",
"name",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"m",
".",
"removeAndReturnController",
"(",
"name",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// RemoveController stops and removes a controller from the manager. If DoFunc
// is currently running, DoFunc is allowed to complete in the background.
|
[
"RemoveController",
"stops",
"and",
"removes",
"a",
"controller",
"from",
"the",
"manager",
".",
"If",
"DoFunc",
"is",
"currently",
"running",
"DoFunc",
"is",
"allowed",
"to",
"complete",
"in",
"the",
"background",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L160-L163
|
162,423 |
cilium/cilium
|
pkg/controller/manager.go
|
TerminationChannel
|
func (m *Manager) TerminationChannel(name string) chan struct{} {
if c := m.lookup(name); c != nil {
return c.terminated
}
c := make(chan struct{}, 0)
close(c)
return c
}
|
go
|
func (m *Manager) TerminationChannel(name string) chan struct{} {
if c := m.lookup(name); c != nil {
return c.terminated
}
c := make(chan struct{}, 0)
close(c)
return c
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"TerminationChannel",
"(",
"name",
"string",
")",
"chan",
"struct",
"{",
"}",
"{",
"if",
"c",
":=",
"m",
".",
"lookup",
"(",
"name",
")",
";",
"c",
"!=",
"nil",
"{",
"return",
"c",
".",
"terminated",
"\n",
"}",
"\n\n",
"c",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
"\n",
"close",
"(",
"c",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// TerminationChannel returns a channel that is closed after the controller has
// been terminated
|
[
"TerminationChannel",
"returns",
"a",
"channel",
"that",
"is",
"closed",
"after",
"the",
"controller",
"has",
"been",
"terminated"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L178-L186
|
162,424 |
cilium/cilium
|
pkg/controller/manager.go
|
RemoveAllAndWait
|
func (m *Manager) RemoveAllAndWait() {
ctrls := m.removeAll()
for _, ctrl := range ctrls {
<-ctrl.terminated
}
}
|
go
|
func (m *Manager) RemoveAllAndWait() {
ctrls := m.removeAll()
for _, ctrl := range ctrls {
<-ctrl.terminated
}
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"RemoveAllAndWait",
"(",
")",
"{",
"ctrls",
":=",
"m",
".",
"removeAll",
"(",
")",
"\n",
"for",
"_",
",",
"ctrl",
":=",
"range",
"ctrls",
"{",
"<-",
"ctrl",
".",
"terminated",
"\n",
"}",
"\n",
"}"
] |
// RemoveAllAndWait stops and removes all controllers of the manager and then
// waits for all controllers to exit
|
[
"RemoveAllAndWait",
"stops",
"and",
"removes",
"all",
"controllers",
"of",
"the",
"manager",
"and",
"then",
"waits",
"for",
"all",
"controllers",
"to",
"exit"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L213-L218
|
162,425 |
cilium/cilium
|
pkg/controller/manager.go
|
GetStatusModel
|
func (m *Manager) GetStatusModel() models.ControllerStatuses {
// Create a copy of pointers to current controller so we can unlock the
// manager mutex quickly again
controllers := controllerMap{}
m.mutex.RLock()
for key, c := range m.controllers {
controllers[key] = c
}
m.mutex.RUnlock()
statuses := models.ControllerStatuses{}
for _, c := range controllers {
statuses = append(statuses, c.GetStatusModel())
}
return statuses
}
|
go
|
func (m *Manager) GetStatusModel() models.ControllerStatuses {
// Create a copy of pointers to current controller so we can unlock the
// manager mutex quickly again
controllers := controllerMap{}
m.mutex.RLock()
for key, c := range m.controllers {
controllers[key] = c
}
m.mutex.RUnlock()
statuses := models.ControllerStatuses{}
for _, c := range controllers {
statuses = append(statuses, c.GetStatusModel())
}
return statuses
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"GetStatusModel",
"(",
")",
"models",
".",
"ControllerStatuses",
"{",
"// Create a copy of pointers to current controller so we can unlock the",
"// manager mutex quickly again",
"controllers",
":=",
"controllerMap",
"{",
"}",
"\n",
"m",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"for",
"key",
",",
"c",
":=",
"range",
"m",
".",
"controllers",
"{",
"controllers",
"[",
"key",
"]",
"=",
"c",
"\n",
"}",
"\n",
"m",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"statuses",
":=",
"models",
".",
"ControllerStatuses",
"{",
"}",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"controllers",
"{",
"statuses",
"=",
"append",
"(",
"statuses",
",",
"c",
".",
"GetStatusModel",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"statuses",
"\n",
"}"
] |
// GetStatusModel returns the status of all controllers as models.ControllerStatuses
|
[
"GetStatusModel",
"returns",
"the",
"status",
"of",
"all",
"controllers",
"as",
"models",
".",
"ControllerStatuses"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L221-L237
|
162,426 |
cilium/cilium
|
pkg/controller/manager.go
|
FakeManager
|
func FakeManager(failingControllers int) *Manager {
m := &Manager{
controllers: controllerMap{},
}
for i := 0; i < failingControllers; i++ {
ctrl := &Controller{
name: fmt.Sprintf("controller-%d", i),
uuid: fmt.Sprintf("%d", i),
stop: make(chan struct{}, 0),
update: make(chan struct{}, 1),
terminated: make(chan struct{}, 0),
lastError: fmt.Errorf("controller failed"),
failureCount: 1,
consecutiveErrors: 1,
}
ctrl.ctxDoFunc, ctrl.cancelDoFunc = context.WithCancel(context.Background())
m.controllers[ctrl.name] = ctrl
}
return m
}
|
go
|
func FakeManager(failingControllers int) *Manager {
m := &Manager{
controllers: controllerMap{},
}
for i := 0; i < failingControllers; i++ {
ctrl := &Controller{
name: fmt.Sprintf("controller-%d", i),
uuid: fmt.Sprintf("%d", i),
stop: make(chan struct{}, 0),
update: make(chan struct{}, 1),
terminated: make(chan struct{}, 0),
lastError: fmt.Errorf("controller failed"),
failureCount: 1,
consecutiveErrors: 1,
}
ctrl.ctxDoFunc, ctrl.cancelDoFunc = context.WithCancel(context.Background())
m.controllers[ctrl.name] = ctrl
}
return m
}
|
[
"func",
"FakeManager",
"(",
"failingControllers",
"int",
")",
"*",
"Manager",
"{",
"m",
":=",
"&",
"Manager",
"{",
"controllers",
":",
"controllerMap",
"{",
"}",
",",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"failingControllers",
";",
"i",
"++",
"{",
"ctrl",
":=",
"&",
"Controller",
"{",
"name",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
",",
"uuid",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
",",
"stop",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
",",
"update",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"terminated",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"0",
")",
",",
"lastError",
":",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
",",
"failureCount",
":",
"1",
",",
"consecutiveErrors",
":",
"1",
",",
"}",
"\n\n",
"ctrl",
".",
"ctxDoFunc",
",",
"ctrl",
".",
"cancelDoFunc",
"=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"m",
".",
"controllers",
"[",
"ctrl",
".",
"name",
"]",
"=",
"ctrl",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// FakeManager returns a fake controller manager with the specified number of
// failing controllers. The returned manager is identical in any regard except
// for internal pointers.
|
[
"FakeManager",
"returns",
"a",
"fake",
"controller",
"manager",
"with",
"the",
"specified",
"number",
"of",
"failing",
"controllers",
".",
"The",
"returned",
"manager",
"is",
"identical",
"in",
"any",
"regard",
"except",
"for",
"internal",
"pointers",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/manager.go#L242-L264
|
162,427 |
cilium/cilium
|
api/v1/health/client/cilium_health_client.go
|
New
|
func New(transport runtime.ClientTransport, formats strfmt.Registry) *CiliumHealth {
// ensure nullable parameters have default
if formats == nil {
formats = strfmt.Default
}
cli := new(CiliumHealth)
cli.Transport = transport
cli.Connectivity = connectivity.New(transport, formats)
cli.Restapi = restapi.New(transport, formats)
return cli
}
|
go
|
func New(transport runtime.ClientTransport, formats strfmt.Registry) *CiliumHealth {
// ensure nullable parameters have default
if formats == nil {
formats = strfmt.Default
}
cli := new(CiliumHealth)
cli.Transport = transport
cli.Connectivity = connectivity.New(transport, formats)
cli.Restapi = restapi.New(transport, formats)
return cli
}
|
[
"func",
"New",
"(",
"transport",
"runtime",
".",
"ClientTransport",
",",
"formats",
"strfmt",
".",
"Registry",
")",
"*",
"CiliumHealth",
"{",
"// ensure nullable parameters have default",
"if",
"formats",
"==",
"nil",
"{",
"formats",
"=",
"strfmt",
".",
"Default",
"\n",
"}",
"\n\n",
"cli",
":=",
"new",
"(",
"CiliumHealth",
")",
"\n",
"cli",
".",
"Transport",
"=",
"transport",
"\n\n",
"cli",
".",
"Connectivity",
"=",
"connectivity",
".",
"New",
"(",
"transport",
",",
"formats",
")",
"\n\n",
"cli",
".",
"Restapi",
"=",
"restapi",
".",
"New",
"(",
"transport",
",",
"formats",
")",
"\n\n",
"return",
"cli",
"\n",
"}"
] |
// New creates a new cilium health client
|
[
"New",
"creates",
"a",
"new",
"cilium",
"health",
"client"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/client/cilium_health_client.go#L52-L66
|
162,428 |
cilium/cilium
|
operator/api.go
|
StartServer
|
func StartServer(addr string, shutdownSignal <-chan struct{}) {
log.Infof("Starting apiserver on address %s", addr)
http.HandleFunc("/healthz", healthHandler)
srv := &http.Server{Addr: addr}
go func() {
<-shutdownSignal
if err := srv.Shutdown(context.Background()); err != nil {
log.WithError(err).Error("apiserver shutdown")
}
}()
if err := srv.ListenAndServe(); err != nil {
log.WithError(err).Error("apiserver listen")
}
}
|
go
|
func StartServer(addr string, shutdownSignal <-chan struct{}) {
log.Infof("Starting apiserver on address %s", addr)
http.HandleFunc("/healthz", healthHandler)
srv := &http.Server{Addr: addr}
go func() {
<-shutdownSignal
if err := srv.Shutdown(context.Background()); err != nil {
log.WithError(err).Error("apiserver shutdown")
}
}()
if err := srv.ListenAndServe(); err != nil {
log.WithError(err).Error("apiserver listen")
}
}
|
[
"func",
"StartServer",
"(",
"addr",
"string",
",",
"shutdownSignal",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n\n",
"http",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"healthHandler",
")",
"\n\n",
"srv",
":=",
"&",
"http",
".",
"Server",
"{",
"Addr",
":",
"addr",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"<-",
"shutdownSignal",
"\n",
"if",
"err",
":=",
"srv",
".",
"Shutdown",
"(",
"context",
".",
"Background",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
":=",
"srv",
".",
"ListenAndServe",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// StartServer starts an api server listening on the given address.
|
[
"StartServer",
"starts",
"an",
"api",
"server",
"listening",
"on",
"the",
"given",
"address",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/operator/api.go#L27-L44
|
162,429 |
cilium/cilium
|
operator/api.go
|
checkStatus
|
func checkStatus() error {
if client := kvstore.Client(); client == nil {
return fmt.Errorf("kvstore client not configured")
} else if _, err := client.Status(); err != nil {
return err
} else if _, err := k8s.Client().Discovery().ServerVersion(); err != nil {
return err
}
return nil
}
|
go
|
func checkStatus() error {
if client := kvstore.Client(); client == nil {
return fmt.Errorf("kvstore client not configured")
} else if _, err := client.Status(); err != nil {
return err
} else if _, err := k8s.Client().Discovery().ServerVersion(); err != nil {
return err
}
return nil
}
|
[
"func",
"checkStatus",
"(",
")",
"error",
"{",
"if",
"client",
":=",
"kvstore",
".",
"Client",
"(",
")",
";",
"client",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"err",
":=",
"client",
".",
"Status",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"_",
",",
"err",
":=",
"k8s",
".",
"Client",
"(",
")",
".",
"Discovery",
"(",
")",
".",
"ServerVersion",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// checkStatus checks the connection status to the kvstore and
// k8s apiserver and returns an error if any of them is unhealthy
|
[
"checkStatus",
"checks",
"the",
"connection",
"status",
"to",
"the",
"kvstore",
"and",
"k8s",
"apiserver",
"and",
"returns",
"an",
"error",
"if",
"any",
"of",
"them",
"is",
"unhealthy"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/operator/api.go#L63-L74
|
162,430 |
cilium/cilium
|
pkg/client/ipam.go
|
IPAMAllocate
|
func (c *Client) IPAMAllocate(family, owner string) (*models.IPAMResponse, error) {
params := ipam.NewPostIPAMParams().WithTimeout(api.ClientTimeout)
if family != "" {
params.SetFamily(&family)
}
if owner != "" {
params.SetOwner(&owner)
}
resp, err := c.IPAM.PostIPAM(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
}
|
go
|
func (c *Client) IPAMAllocate(family, owner string) (*models.IPAMResponse, error) {
params := ipam.NewPostIPAMParams().WithTimeout(api.ClientTimeout)
if family != "" {
params.SetFamily(&family)
}
if owner != "" {
params.SetOwner(&owner)
}
resp, err := c.IPAM.PostIPAM(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"IPAMAllocate",
"(",
"family",
",",
"owner",
"string",
")",
"(",
"*",
"models",
".",
"IPAMResponse",
",",
"error",
")",
"{",
"params",
":=",
"ipam",
".",
"NewPostIPAMParams",
"(",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n\n",
"if",
"family",
"!=",
"\"",
"\"",
"{",
"params",
".",
"SetFamily",
"(",
"&",
"family",
")",
"\n",
"}",
"\n\n",
"if",
"owner",
"!=",
"\"",
"\"",
"{",
"params",
".",
"SetOwner",
"(",
"&",
"owner",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"IPAM",
".",
"PostIPAM",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"nil",
"\n",
"}"
] |
// IPAMAllocate allocates an IP address out of address family specific pool.
|
[
"IPAMAllocate",
"allocates",
"an",
"IP",
"address",
"out",
"of",
"address",
"family",
"specific",
"pool",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/ipam.go#L29-L45
|
162,431 |
cilium/cilium
|
pkg/client/ipam.go
|
IPAMAllocateIP
|
func (c *Client) IPAMAllocateIP(ip, owner string) error {
params := ipam.NewPostIPAMIPParams().WithIP(ip).WithOwner(&owner).WithTimeout(api.ClientTimeout)
_, err := c.IPAM.PostIPAMIP(params)
return Hint(err)
}
|
go
|
func (c *Client) IPAMAllocateIP(ip, owner string) error {
params := ipam.NewPostIPAMIPParams().WithIP(ip).WithOwner(&owner).WithTimeout(api.ClientTimeout)
_, err := c.IPAM.PostIPAMIP(params)
return Hint(err)
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"IPAMAllocateIP",
"(",
"ip",
",",
"owner",
"string",
")",
"error",
"{",
"params",
":=",
"ipam",
".",
"NewPostIPAMIPParams",
"(",
")",
".",
"WithIP",
"(",
"ip",
")",
".",
"WithOwner",
"(",
"&",
"owner",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"IPAM",
".",
"PostIPAMIP",
"(",
"params",
")",
"\n",
"return",
"Hint",
"(",
"err",
")",
"\n",
"}"
] |
// IPAMAllocateIP tries to allocate a particular IP address.
|
[
"IPAMAllocateIP",
"tries",
"to",
"allocate",
"a",
"particular",
"IP",
"address",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/ipam.go#L48-L52
|
162,432 |
cilium/cilium
|
pkg/client/ipam.go
|
IPAMReleaseIP
|
func (c *Client) IPAMReleaseIP(ip string) error {
params := ipam.NewDeleteIPAMIPParams().WithIP(ip).WithTimeout(api.ClientTimeout)
_, err := c.IPAM.DeleteIPAMIP(params)
return Hint(err)
}
|
go
|
func (c *Client) IPAMReleaseIP(ip string) error {
params := ipam.NewDeleteIPAMIPParams().WithIP(ip).WithTimeout(api.ClientTimeout)
_, err := c.IPAM.DeleteIPAMIP(params)
return Hint(err)
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"IPAMReleaseIP",
"(",
"ip",
"string",
")",
"error",
"{",
"params",
":=",
"ipam",
".",
"NewDeleteIPAMIPParams",
"(",
")",
".",
"WithIP",
"(",
"ip",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"IPAM",
".",
"DeleteIPAMIP",
"(",
"params",
")",
"\n",
"return",
"Hint",
"(",
"err",
")",
"\n",
"}"
] |
// IPAMReleaseIP releases a IP address back to the pool.
|
[
"IPAMReleaseIP",
"releases",
"a",
"IP",
"address",
"back",
"to",
"the",
"pool",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/ipam.go#L55-L59
|
162,433 |
cilium/cilium
|
pkg/controller/controller.go
|
GetSuccessCount
|
func (c *Controller) GetSuccessCount() int {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.successCount
}
|
go
|
func (c *Controller) GetSuccessCount() int {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.successCount
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"GetSuccessCount",
"(",
")",
"int",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"successCount",
"\n",
"}"
] |
// GetSuccessCount returns the number of successful controller runs
|
[
"GetSuccessCount",
"returns",
"the",
"number",
"of",
"successful",
"controller",
"runs"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L157-L162
|
162,434 |
cilium/cilium
|
pkg/controller/controller.go
|
GetFailureCount
|
func (c *Controller) GetFailureCount() int {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.failureCount
}
|
go
|
func (c *Controller) GetFailureCount() int {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.failureCount
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"GetFailureCount",
"(",
")",
"int",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"failureCount",
"\n",
"}"
] |
// GetFailureCount returns the number of failed controller runs
|
[
"GetFailureCount",
"returns",
"the",
"number",
"of",
"failed",
"controller",
"runs"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L165-L170
|
162,435 |
cilium/cilium
|
pkg/controller/controller.go
|
GetLastError
|
func (c *Controller) GetLastError() error {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.lastError
}
|
go
|
func (c *Controller) GetLastError() error {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.lastError
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"GetLastError",
"(",
")",
"error",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"lastError",
"\n",
"}"
] |
// GetLastError returns the last error returned
|
[
"GetLastError",
"returns",
"the",
"last",
"error",
"returned"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L173-L178
|
162,436 |
cilium/cilium
|
pkg/controller/controller.go
|
GetLastErrorTimestamp
|
func (c *Controller) GetLastErrorTimestamp() time.Time {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.lastErrorStamp
}
|
go
|
func (c *Controller) GetLastErrorTimestamp() time.Time {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.lastErrorStamp
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"GetLastErrorTimestamp",
"(",
")",
"time",
".",
"Time",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"lastErrorStamp",
"\n",
"}"
] |
// GetLastErrorTimestamp returns the last error returned
|
[
"GetLastErrorTimestamp",
"returns",
"the",
"last",
"error",
"returned"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L181-L186
|
162,437 |
cilium/cilium
|
pkg/controller/controller.go
|
updateParamsLocked
|
func (c *Controller) updateParamsLocked(params ControllerParams) {
c.params = params
maxInterval := time.Duration(option.Config.MaxControllerInterval) * time.Second
if maxInterval > 0 && params.RunInterval > maxInterval {
c.getLogger().Infof("Limiting interval to %s", maxInterval)
c.params.RunInterval = maxInterval
}
}
|
go
|
func (c *Controller) updateParamsLocked(params ControllerParams) {
c.params = params
maxInterval := time.Duration(option.Config.MaxControllerInterval) * time.Second
if maxInterval > 0 && params.RunInterval > maxInterval {
c.getLogger().Infof("Limiting interval to %s", maxInterval)
c.params.RunInterval = maxInterval
}
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"updateParamsLocked",
"(",
"params",
"ControllerParams",
")",
"{",
"c",
".",
"params",
"=",
"params",
"\n\n",
"maxInterval",
":=",
"time",
".",
"Duration",
"(",
"option",
".",
"Config",
".",
"MaxControllerInterval",
")",
"*",
"time",
".",
"Second",
"\n",
"if",
"maxInterval",
">",
"0",
"&&",
"params",
".",
"RunInterval",
">",
"maxInterval",
"{",
"c",
".",
"getLogger",
"(",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"maxInterval",
")",
"\n",
"c",
".",
"params",
".",
"RunInterval",
"=",
"maxInterval",
"\n",
"}",
"\n",
"}"
] |
// updateParamsLocked sets the specified controller's parameters.
//
// If the RunInterval exceeds ControllerMaxInterval, it will be capped.
|
[
"updateParamsLocked",
"sets",
"the",
"specified",
"controller",
"s",
"parameters",
".",
"If",
"the",
"RunInterval",
"exceeds",
"ControllerMaxInterval",
"it",
"will",
"be",
"capped",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L303-L311
|
162,438 |
cilium/cilium
|
pkg/controller/controller.go
|
getLogger
|
func (c *Controller) getLogger() *logrus.Entry {
return log.WithFields(logrus.Fields{
fieldControllerName: c.name,
fieldUUID: c.uuid,
})
}
|
go
|
func (c *Controller) getLogger() *logrus.Entry {
return log.WithFields(logrus.Fields{
fieldControllerName: c.name,
fieldUUID: c.uuid,
})
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"getLogger",
"(",
")",
"*",
"logrus",
".",
"Entry",
"{",
"return",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"fieldControllerName",
":",
"c",
".",
"name",
",",
"fieldUUID",
":",
"c",
".",
"uuid",
",",
"}",
")",
"\n",
"}"
] |
// logger returns a logrus object with controllerName and UUID fields.
|
[
"logger",
"returns",
"a",
"logrus",
"object",
"with",
"controllerName",
"and",
"UUID",
"fields",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L323-L328
|
162,439 |
cilium/cilium
|
pkg/controller/controller.go
|
GetStatusModel
|
func (c *Controller) GetStatusModel() *models.ControllerStatus {
c.mutex.RLock()
defer c.mutex.RUnlock()
status := &models.ControllerStatus{
Name: c.name,
UUID: strfmt.UUID(c.uuid),
Configuration: &models.ControllerStatusConfiguration{
ErrorRetry: !c.params.NoErrorRetry,
ErrorRetryBase: strfmt.Duration(c.params.ErrorRetryBaseDuration),
Interval: strfmt.Duration(c.params.RunInterval),
},
Status: &models.ControllerStatusStatus{
SuccessCount: int64(c.successCount),
LastSuccessTimestamp: strfmt.DateTime(c.lastSuccessStamp),
FailureCount: int64(c.failureCount),
LastFailureTimestamp: strfmt.DateTime(c.lastErrorStamp),
ConsecutiveFailureCount: int64(c.consecutiveErrors),
},
}
if c.lastError != nil {
status.Status.LastFailureMsg = c.lastError.Error()
}
return status
}
|
go
|
func (c *Controller) GetStatusModel() *models.ControllerStatus {
c.mutex.RLock()
defer c.mutex.RUnlock()
status := &models.ControllerStatus{
Name: c.name,
UUID: strfmt.UUID(c.uuid),
Configuration: &models.ControllerStatusConfiguration{
ErrorRetry: !c.params.NoErrorRetry,
ErrorRetryBase: strfmt.Duration(c.params.ErrorRetryBaseDuration),
Interval: strfmt.Duration(c.params.RunInterval),
},
Status: &models.ControllerStatusStatus{
SuccessCount: int64(c.successCount),
LastSuccessTimestamp: strfmt.DateTime(c.lastSuccessStamp),
FailureCount: int64(c.failureCount),
LastFailureTimestamp: strfmt.DateTime(c.lastErrorStamp),
ConsecutiveFailureCount: int64(c.consecutiveErrors),
},
}
if c.lastError != nil {
status.Status.LastFailureMsg = c.lastError.Error()
}
return status
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"GetStatusModel",
"(",
")",
"*",
"models",
".",
"ControllerStatus",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"status",
":=",
"&",
"models",
".",
"ControllerStatus",
"{",
"Name",
":",
"c",
".",
"name",
",",
"UUID",
":",
"strfmt",
".",
"UUID",
"(",
"c",
".",
"uuid",
")",
",",
"Configuration",
":",
"&",
"models",
".",
"ControllerStatusConfiguration",
"{",
"ErrorRetry",
":",
"!",
"c",
".",
"params",
".",
"NoErrorRetry",
",",
"ErrorRetryBase",
":",
"strfmt",
".",
"Duration",
"(",
"c",
".",
"params",
".",
"ErrorRetryBaseDuration",
")",
",",
"Interval",
":",
"strfmt",
".",
"Duration",
"(",
"c",
".",
"params",
".",
"RunInterval",
")",
",",
"}",
",",
"Status",
":",
"&",
"models",
".",
"ControllerStatusStatus",
"{",
"SuccessCount",
":",
"int64",
"(",
"c",
".",
"successCount",
")",
",",
"LastSuccessTimestamp",
":",
"strfmt",
".",
"DateTime",
"(",
"c",
".",
"lastSuccessStamp",
")",
",",
"FailureCount",
":",
"int64",
"(",
"c",
".",
"failureCount",
")",
",",
"LastFailureTimestamp",
":",
"strfmt",
".",
"DateTime",
"(",
"c",
".",
"lastErrorStamp",
")",
",",
"ConsecutiveFailureCount",
":",
"int64",
"(",
"c",
".",
"consecutiveErrors",
")",
",",
"}",
",",
"}",
"\n\n",
"if",
"c",
".",
"lastError",
"!=",
"nil",
"{",
"status",
".",
"Status",
".",
"LastFailureMsg",
"=",
"c",
".",
"lastError",
".",
"Error",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"status",
"\n",
"}"
] |
// GetStatusModel returns a models.ControllerStatus representing the
// controller's configuration & status
|
[
"GetStatusModel",
"returns",
"a",
"models",
".",
"ControllerStatus",
"representing",
"the",
"controller",
"s",
"configuration",
"&",
"status"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L332-L358
|
162,440 |
cilium/cilium
|
pkg/controller/controller.go
|
recordError
|
func (c *Controller) recordError(err error) {
c.lastError = err
c.lastErrorStamp = time.Now()
c.failureCount++
c.consecutiveErrors++
metrics.ControllerRuns.WithLabelValues(failure).Inc()
metrics.ControllerRunsDuration.WithLabelValues(failure).Observe(c.lastDuration.Seconds())
}
|
go
|
func (c *Controller) recordError(err error) {
c.lastError = err
c.lastErrorStamp = time.Now()
c.failureCount++
c.consecutiveErrors++
metrics.ControllerRuns.WithLabelValues(failure).Inc()
metrics.ControllerRunsDuration.WithLabelValues(failure).Observe(c.lastDuration.Seconds())
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"recordError",
"(",
"err",
"error",
")",
"{",
"c",
".",
"lastError",
"=",
"err",
"\n",
"c",
".",
"lastErrorStamp",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"c",
".",
"failureCount",
"++",
"\n",
"c",
".",
"consecutiveErrors",
"++",
"\n",
"metrics",
".",
"ControllerRuns",
".",
"WithLabelValues",
"(",
"failure",
")",
".",
"Inc",
"(",
")",
"\n",
"metrics",
".",
"ControllerRunsDuration",
".",
"WithLabelValues",
"(",
"failure",
")",
".",
"Observe",
"(",
"c",
".",
"lastDuration",
".",
"Seconds",
"(",
")",
")",
"\n",
"}"
] |
// recordError updates all statistic collection variables on error
// c.mutex must be held.
|
[
"recordError",
"updates",
"all",
"statistic",
"collection",
"variables",
"on",
"error",
"c",
".",
"mutex",
"must",
"be",
"held",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L362-L369
|
162,441 |
cilium/cilium
|
pkg/controller/controller.go
|
recordSuccess
|
func (c *Controller) recordSuccess() {
c.lastError = nil
c.lastSuccessStamp = time.Now()
c.successCount++
c.consecutiveErrors = 0
metrics.ControllerRuns.WithLabelValues(success).Inc()
metrics.ControllerRunsDuration.WithLabelValues(success).Observe(c.lastDuration.Seconds())
}
|
go
|
func (c *Controller) recordSuccess() {
c.lastError = nil
c.lastSuccessStamp = time.Now()
c.successCount++
c.consecutiveErrors = 0
metrics.ControllerRuns.WithLabelValues(success).Inc()
metrics.ControllerRunsDuration.WithLabelValues(success).Observe(c.lastDuration.Seconds())
}
|
[
"func",
"(",
"c",
"*",
"Controller",
")",
"recordSuccess",
"(",
")",
"{",
"c",
".",
"lastError",
"=",
"nil",
"\n",
"c",
".",
"lastSuccessStamp",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"c",
".",
"successCount",
"++",
"\n",
"c",
".",
"consecutiveErrors",
"=",
"0",
"\n\n",
"metrics",
".",
"ControllerRuns",
".",
"WithLabelValues",
"(",
"success",
")",
".",
"Inc",
"(",
")",
"\n",
"metrics",
".",
"ControllerRunsDuration",
".",
"WithLabelValues",
"(",
"success",
")",
".",
"Observe",
"(",
"c",
".",
"lastDuration",
".",
"Seconds",
"(",
")",
")",
"\n",
"}"
] |
// recordSuccess updates all statistic collection variables on success
// c.mutex must be held.
|
[
"recordSuccess",
"updates",
"all",
"statistic",
"collection",
"variables",
"on",
"success",
"c",
".",
"mutex",
"must",
"be",
"held",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/controller/controller.go#L373-L381
|
162,442 |
cilium/cilium
|
pkg/policy/api/cidr.go
|
MatchesAll
|
func (c *CIDR) MatchesAll() bool {
for _, wildcard := range CIDRMatchAll {
if *c == wildcard {
return true
}
}
return false
}
|
go
|
func (c *CIDR) MatchesAll() bool {
for _, wildcard := range CIDRMatchAll {
if *c == wildcard {
return true
}
}
return false
}
|
[
"func",
"(",
"c",
"*",
"CIDR",
")",
"MatchesAll",
"(",
")",
"bool",
"{",
"for",
"_",
",",
"wildcard",
":=",
"range",
"CIDRMatchAll",
"{",
"if",
"*",
"c",
"==",
"wildcard",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// MatchesAll determines whether the CIDR matches all traffic.
|
[
"MatchesAll",
"determines",
"whether",
"the",
"CIDR",
"matches",
"all",
"traffic",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/cidr.go#L33-L40
|
162,443 |
cilium/cilium
|
pkg/policy/api/cidr.go
|
GetAsEndpointSelectors
|
func (s CIDRSlice) GetAsEndpointSelectors() EndpointSelectorSlice {
// If multiple CIDRs representing reserved:world are in this CIDRSlice,
// we only have to add the EndpointSelector representing reserved:world
// once.
var hasWorldBeenAdded bool
slice := EndpointSelectorSlice{}
for _, cidr := range s {
if cidr.MatchesAll() && !hasWorldBeenAdded {
hasWorldBeenAdded = true
slice = append(slice, ReservedEndpointSelectors[labels.IDNameWorld])
}
lbl, err := cidrpkg.IPStringToLabel(string(cidr))
if err == nil {
slice = append(slice, NewESFromLabels(lbl))
}
// TODO: Log the error?
}
return slice
}
|
go
|
func (s CIDRSlice) GetAsEndpointSelectors() EndpointSelectorSlice {
// If multiple CIDRs representing reserved:world are in this CIDRSlice,
// we only have to add the EndpointSelector representing reserved:world
// once.
var hasWorldBeenAdded bool
slice := EndpointSelectorSlice{}
for _, cidr := range s {
if cidr.MatchesAll() && !hasWorldBeenAdded {
hasWorldBeenAdded = true
slice = append(slice, ReservedEndpointSelectors[labels.IDNameWorld])
}
lbl, err := cidrpkg.IPStringToLabel(string(cidr))
if err == nil {
slice = append(slice, NewESFromLabels(lbl))
}
// TODO: Log the error?
}
return slice
}
|
[
"func",
"(",
"s",
"CIDRSlice",
")",
"GetAsEndpointSelectors",
"(",
")",
"EndpointSelectorSlice",
"{",
"// If multiple CIDRs representing reserved:world are in this CIDRSlice,",
"// we only have to add the EndpointSelector representing reserved:world",
"// once.",
"var",
"hasWorldBeenAdded",
"bool",
"\n",
"slice",
":=",
"EndpointSelectorSlice",
"{",
"}",
"\n",
"for",
"_",
",",
"cidr",
":=",
"range",
"s",
"{",
"if",
"cidr",
".",
"MatchesAll",
"(",
")",
"&&",
"!",
"hasWorldBeenAdded",
"{",
"hasWorldBeenAdded",
"=",
"true",
"\n",
"slice",
"=",
"append",
"(",
"slice",
",",
"ReservedEndpointSelectors",
"[",
"labels",
".",
"IDNameWorld",
"]",
")",
"\n",
"}",
"\n",
"lbl",
",",
"err",
":=",
"cidrpkg",
".",
"IPStringToLabel",
"(",
"string",
"(",
"cidr",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"slice",
"=",
"append",
"(",
"slice",
",",
"NewESFromLabels",
"(",
"lbl",
")",
")",
"\n",
"}",
"\n",
"// TODO: Log the error?",
"}",
"\n\n",
"return",
"slice",
"\n",
"}"
] |
// GetAsEndpointSelectors returns the provided CIDR slice as a slice of
// endpoint selectors
|
[
"GetAsEndpointSelectors",
"returns",
"the",
"provided",
"CIDR",
"slice",
"as",
"a",
"slice",
"of",
"endpoint",
"selectors"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/cidr.go#L71-L90
|
162,444 |
cilium/cilium
|
pkg/policy/api/cidr.go
|
StringSlice
|
func (s CIDRSlice) StringSlice() []string {
result := make([]string, 0, len(s))
for _, c := range s {
result = append(result, string(c))
}
return result
}
|
go
|
func (s CIDRSlice) StringSlice() []string {
result := make([]string, 0, len(s))
for _, c := range s {
result = append(result, string(c))
}
return result
}
|
[
"func",
"(",
"s",
"CIDRSlice",
")",
"StringSlice",
"(",
")",
"[",
"]",
"string",
"{",
"result",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"s",
")",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"s",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"string",
"(",
"c",
")",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// StringSlice returns the CIDR slice as a slice of strings.
|
[
"StringSlice",
"returns",
"the",
"CIDR",
"slice",
"as",
"a",
"slice",
"of",
"strings",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/cidr.go#L93-L99
|
162,445 |
cilium/cilium
|
pkg/policy/api/cidr.go
|
ComputeResultantCIDRSet
|
func ComputeResultantCIDRSet(cidrs CIDRRuleSlice) CIDRSlice {
var allResultantAllowedCIDRs CIDRSlice
for _, s := range cidrs {
_, allowNet, _ := net.ParseCIDR(string(s.Cidr))
var removeSubnets []*net.IPNet
for _, t := range s.ExceptCIDRs {
_, removeSubnet, _ := net.ParseCIDR(string(t))
removeSubnets = append(removeSubnets, removeSubnet)
}
resultantAllowedCIDRs, _ := ip.RemoveCIDRs([]*net.IPNet{allowNet}, removeSubnets)
for _, u := range resultantAllowedCIDRs {
allResultantAllowedCIDRs = append(allResultantAllowedCIDRs, CIDR(u.String()))
}
}
return allResultantAllowedCIDRs
}
|
go
|
func ComputeResultantCIDRSet(cidrs CIDRRuleSlice) CIDRSlice {
var allResultantAllowedCIDRs CIDRSlice
for _, s := range cidrs {
_, allowNet, _ := net.ParseCIDR(string(s.Cidr))
var removeSubnets []*net.IPNet
for _, t := range s.ExceptCIDRs {
_, removeSubnet, _ := net.ParseCIDR(string(t))
removeSubnets = append(removeSubnets, removeSubnet)
}
resultantAllowedCIDRs, _ := ip.RemoveCIDRs([]*net.IPNet{allowNet}, removeSubnets)
for _, u := range resultantAllowedCIDRs {
allResultantAllowedCIDRs = append(allResultantAllowedCIDRs, CIDR(u.String()))
}
}
return allResultantAllowedCIDRs
}
|
[
"func",
"ComputeResultantCIDRSet",
"(",
"cidrs",
"CIDRRuleSlice",
")",
"CIDRSlice",
"{",
"var",
"allResultantAllowedCIDRs",
"CIDRSlice",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"cidrs",
"{",
"_",
",",
"allowNet",
",",
"_",
":=",
"net",
".",
"ParseCIDR",
"(",
"string",
"(",
"s",
".",
"Cidr",
")",
")",
"\n\n",
"var",
"removeSubnets",
"[",
"]",
"*",
"net",
".",
"IPNet",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"s",
".",
"ExceptCIDRs",
"{",
"_",
",",
"removeSubnet",
",",
"_",
":=",
"net",
".",
"ParseCIDR",
"(",
"string",
"(",
"t",
")",
")",
"\n",
"removeSubnets",
"=",
"append",
"(",
"removeSubnets",
",",
"removeSubnet",
")",
"\n",
"}",
"\n",
"resultantAllowedCIDRs",
",",
"_",
":=",
"ip",
".",
"RemoveCIDRs",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
"{",
"allowNet",
"}",
",",
"removeSubnets",
")",
"\n\n",
"for",
"_",
",",
"u",
":=",
"range",
"resultantAllowedCIDRs",
"{",
"allResultantAllowedCIDRs",
"=",
"append",
"(",
"allResultantAllowedCIDRs",
",",
"CIDR",
"(",
"u",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"allResultantAllowedCIDRs",
"\n",
"}"
] |
// ComputeResultantCIDRSet converts a slice of CIDRRules into a slice of
// individual CIDRs. This expands the cidr defined by each CIDRRule, applies
// the CIDR exceptions defined in "ExceptCIDRs", and forms a minimal set of
// CIDRs that cover all of the CIDRRules.
//
// Assumes no error checking is necessary as CIDRRule.Sanitize already does this.
|
[
"ComputeResultantCIDRSet",
"converts",
"a",
"slice",
"of",
"CIDRRules",
"into",
"a",
"slice",
"of",
"individual",
"CIDRs",
".",
"This",
"expands",
"the",
"cidr",
"defined",
"by",
"each",
"CIDRRule",
"applies",
"the",
"CIDR",
"exceptions",
"defined",
"in",
"ExceptCIDRs",
"and",
"forms",
"a",
"minimal",
"set",
"of",
"CIDRs",
"that",
"cover",
"all",
"of",
"the",
"CIDRRules",
".",
"Assumes",
"no",
"error",
"checking",
"is",
"necessary",
"as",
"CIDRRule",
".",
"Sanitize",
"already",
"does",
"this",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/cidr.go#L119-L136
|
162,446 |
cilium/cilium
|
api/v1/health/server/restapi/get_healthz.go
|
NewGetHealthz
|
func NewGetHealthz(ctx *middleware.Context, handler GetHealthzHandler) *GetHealthz {
return &GetHealthz{Context: ctx, Handler: handler}
}
|
go
|
func NewGetHealthz(ctx *middleware.Context, handler GetHealthzHandler) *GetHealthz {
return &GetHealthz{Context: ctx, Handler: handler}
}
|
[
"func",
"NewGetHealthz",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetHealthzHandler",
")",
"*",
"GetHealthz",
"{",
"return",
"&",
"GetHealthz",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] |
// NewGetHealthz creates a new http.Handler for the get healthz operation
|
[
"NewGetHealthz",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"healthz",
"operation"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/get_healthz.go#L28-L30
|
162,447 |
cilium/cilium
|
plugins/cilium-cni/chaining/api/api.go
|
Lookup
|
func Lookup(name string) ChainingPlugin {
mutex.RLock()
defer mutex.RUnlock()
return chainingPlugins[name]
}
|
go
|
func Lookup(name string) ChainingPlugin {
mutex.RLock()
defer mutex.RUnlock()
return chainingPlugins[name]
}
|
[
"func",
"Lookup",
"(",
"name",
"string",
")",
"ChainingPlugin",
"{",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"chainingPlugins",
"[",
"name",
"]",
"\n",
"}"
] |
// Lookup searches for a chaining plugin with a given name and returns it
|
[
"Lookup",
"searches",
"for",
"a",
"chaining",
"plugin",
"with",
"a",
"given",
"name",
"and",
"returns",
"it"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/plugins/cilium-cni/chaining/api/api.go#L68-L73
|
162,448 |
cilium/cilium
|
pkg/bpf/endpoint.go
|
NewEndpointKey
|
func NewEndpointKey(ip net.IP) EndpointKey {
result := EndpointKey{}
if ip4 := ip.To4(); ip4 != nil {
result.Family = EndpointKeyIPv4
copy(result.IP[:], ip4)
} else {
result.Family = EndpointKeyIPv6
copy(result.IP[:], ip)
}
result.Key = 0
return result
}
|
go
|
func NewEndpointKey(ip net.IP) EndpointKey {
result := EndpointKey{}
if ip4 := ip.To4(); ip4 != nil {
result.Family = EndpointKeyIPv4
copy(result.IP[:], ip4)
} else {
result.Family = EndpointKeyIPv6
copy(result.IP[:], ip)
}
result.Key = 0
return result
}
|
[
"func",
"NewEndpointKey",
"(",
"ip",
"net",
".",
"IP",
")",
"EndpointKey",
"{",
"result",
":=",
"EndpointKey",
"{",
"}",
"\n\n",
"if",
"ip4",
":=",
"ip",
".",
"To4",
"(",
")",
";",
"ip4",
"!=",
"nil",
"{",
"result",
".",
"Family",
"=",
"EndpointKeyIPv4",
"\n",
"copy",
"(",
"result",
".",
"IP",
"[",
":",
"]",
",",
"ip4",
")",
"\n",
"}",
"else",
"{",
"result",
".",
"Family",
"=",
"EndpointKeyIPv6",
"\n",
"copy",
"(",
"result",
".",
"IP",
"[",
":",
"]",
",",
"ip",
")",
"\n",
"}",
"\n",
"result",
".",
"Key",
"=",
"0",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// NewEndpointKey returns an EndpointKey based on the provided IP address. The
// address family is automatically detected.
|
[
"NewEndpointKey",
"returns",
"an",
"EndpointKey",
"based",
"on",
"the",
"provided",
"IP",
"address",
".",
"The",
"address",
"family",
"is",
"automatically",
"detected",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/endpoint.go#L51-L64
|
162,449 |
cilium/cilium
|
pkg/bpf/endpoint.go
|
ToIP
|
func (k EndpointKey) ToIP() net.IP {
switch k.Family {
case EndpointKeyIPv4:
return k.IP[:4]
case EndpointKeyIPv6:
return k.IP[:]
}
return nil
}
|
go
|
func (k EndpointKey) ToIP() net.IP {
switch k.Family {
case EndpointKeyIPv4:
return k.IP[:4]
case EndpointKeyIPv6:
return k.IP[:]
}
return nil
}
|
[
"func",
"(",
"k",
"EndpointKey",
")",
"ToIP",
"(",
")",
"net",
".",
"IP",
"{",
"switch",
"k",
".",
"Family",
"{",
"case",
"EndpointKeyIPv4",
":",
"return",
"k",
".",
"IP",
"[",
":",
"4",
"]",
"\n",
"case",
"EndpointKeyIPv6",
":",
"return",
"k",
".",
"IP",
"[",
":",
"]",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ToIP converts the EndpointKey into a net.IP structure.
|
[
"ToIP",
"converts",
"the",
"EndpointKey",
"into",
"a",
"net",
".",
"IP",
"structure",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/endpoint.go#L67-L75
|
162,450 |
cilium/cilium
|
pkg/bpf/endpoint.go
|
String
|
func (k EndpointKey) String() string {
if ip := k.ToIP(); ip != nil {
return fmt.Sprintf("%s:%d", ip.String(), k.Key)
}
return "nil"
}
|
go
|
func (k EndpointKey) String() string {
if ip := k.ToIP(); ip != nil {
return fmt.Sprintf("%s:%d", ip.String(), k.Key)
}
return "nil"
}
|
[
"func",
"(",
"k",
"EndpointKey",
")",
"String",
"(",
")",
"string",
"{",
"if",
"ip",
":=",
"k",
".",
"ToIP",
"(",
")",
";",
"ip",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ip",
".",
"String",
"(",
")",
",",
"k",
".",
"Key",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// String provides a string representation of the EndpointKey.
|
[
"String",
"provides",
"a",
"string",
"representation",
"of",
"the",
"EndpointKey",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/endpoint.go#L78-L83
|
162,451 |
cilium/cilium
|
api/v1/server/restapi/endpoint/patch_endpoint_id.go
|
NewPatchEndpointID
|
func NewPatchEndpointID(ctx *middleware.Context, handler PatchEndpointIDHandler) *PatchEndpointID {
return &PatchEndpointID{Context: ctx, Handler: handler}
}
|
go
|
func NewPatchEndpointID(ctx *middleware.Context, handler PatchEndpointIDHandler) *PatchEndpointID {
return &PatchEndpointID{Context: ctx, Handler: handler}
}
|
[
"func",
"NewPatchEndpointID",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"PatchEndpointIDHandler",
")",
"*",
"PatchEndpointID",
"{",
"return",
"&",
"PatchEndpointID",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] |
// NewPatchEndpointID creates a new http.Handler for the patch endpoint ID operation
|
[
"NewPatchEndpointID",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"patch",
"endpoint",
"ID",
"operation"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/patch_endpoint_id.go#L28-L30
|
162,452 |
cilium/cilium
|
cilium-health/launch/launcher.go
|
Run
|
func (ch *CiliumHealth) Run() {
ch.SetTarget(targetName)
ch.SetArgs([]string{"-d"})
// Wait until Cilium API is available
for {
cli, err := ciliumPkg.NewDefaultClient()
if err == nil {
if _, err = cli.Daemon.GetHealthz(nil); err == nil {
break
}
}
log.WithError(err).Debugf("Cannot establish connection to local cilium instance")
time.Sleep(connectRetryInterval)
}
for {
var err error
os.Remove(defaults.SockPath)
ch.Launcher.Run()
ch.client, err = healthPkg.NewDefaultClient()
if err != nil {
log.WithError(err).Infof("Cannot establish connection to local %s instance", targetName)
time.Sleep(connectRetryInterval)
continue
}
for {
status := &models.Status{
State: models.StatusStateOk,
}
if _, err := ch.client.Restapi.GetHello(nil); err != nil {
status.Msg = ciliumPkg.Hint(err).Error()
status.State = models.StatusStateWarning
}
ch.setStatus(status)
time.Sleep(statusProbeInterval)
}
}
}
|
go
|
func (ch *CiliumHealth) Run() {
ch.SetTarget(targetName)
ch.SetArgs([]string{"-d"})
// Wait until Cilium API is available
for {
cli, err := ciliumPkg.NewDefaultClient()
if err == nil {
if _, err = cli.Daemon.GetHealthz(nil); err == nil {
break
}
}
log.WithError(err).Debugf("Cannot establish connection to local cilium instance")
time.Sleep(connectRetryInterval)
}
for {
var err error
os.Remove(defaults.SockPath)
ch.Launcher.Run()
ch.client, err = healthPkg.NewDefaultClient()
if err != nil {
log.WithError(err).Infof("Cannot establish connection to local %s instance", targetName)
time.Sleep(connectRetryInterval)
continue
}
for {
status := &models.Status{
State: models.StatusStateOk,
}
if _, err := ch.client.Restapi.GetHello(nil); err != nil {
status.Msg = ciliumPkg.Hint(err).Error()
status.State = models.StatusStateWarning
}
ch.setStatus(status)
time.Sleep(statusProbeInterval)
}
}
}
|
[
"func",
"(",
"ch",
"*",
"CiliumHealth",
")",
"Run",
"(",
")",
"{",
"ch",
".",
"SetTarget",
"(",
"targetName",
")",
"\n",
"ch",
".",
"SetArgs",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n\n",
"// Wait until Cilium API is available",
"for",
"{",
"cli",
",",
"err",
":=",
"ciliumPkg",
".",
"NewDefaultClient",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"_",
",",
"err",
"=",
"cli",
".",
"Daemon",
".",
"GetHealthz",
"(",
"nil",
")",
";",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"time",
".",
"Sleep",
"(",
"connectRetryInterval",
")",
"\n",
"}",
"\n\n",
"for",
"{",
"var",
"err",
"error",
"\n\n",
"os",
".",
"Remove",
"(",
"defaults",
".",
"SockPath",
")",
"\n",
"ch",
".",
"Launcher",
".",
"Run",
"(",
")",
"\n",
"ch",
".",
"client",
",",
"err",
"=",
"healthPkg",
".",
"NewDefaultClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"targetName",
")",
"\n",
"time",
".",
"Sleep",
"(",
"connectRetryInterval",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"for",
"{",
"status",
":=",
"&",
"models",
".",
"Status",
"{",
"State",
":",
"models",
".",
"StatusStateOk",
",",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"ch",
".",
"client",
".",
"Restapi",
".",
"GetHello",
"(",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"status",
".",
"Msg",
"=",
"ciliumPkg",
".",
"Hint",
"(",
"err",
")",
".",
"Error",
"(",
")",
"\n",
"status",
".",
"State",
"=",
"models",
".",
"StatusStateWarning",
"\n",
"}",
"\n",
"ch",
".",
"setStatus",
"(",
"status",
")",
"\n",
"time",
".",
"Sleep",
"(",
"statusProbeInterval",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Run launches the cilium-health daemon.
|
[
"Run",
"launches",
"the",
"cilium",
"-",
"health",
"daemon",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium-health/launch/launcher.go#L47-L87
|
162,453 |
cilium/cilium
|
cilium-health/launch/launcher.go
|
GetStatus
|
func (ch *CiliumHealth) GetStatus() *models.Status {
ch.Mutex.RLock()
status := ch.status
ch.Mutex.RUnlock()
return status
}
|
go
|
func (ch *CiliumHealth) GetStatus() *models.Status {
ch.Mutex.RLock()
status := ch.status
ch.Mutex.RUnlock()
return status
}
|
[
"func",
"(",
"ch",
"*",
"CiliumHealth",
")",
"GetStatus",
"(",
")",
"*",
"models",
".",
"Status",
"{",
"ch",
".",
"Mutex",
".",
"RLock",
"(",
")",
"\n",
"status",
":=",
"ch",
".",
"status",
"\n",
"ch",
".",
"Mutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"status",
"\n",
"}"
] |
// GetStatus returns the status of the cilium-health daemon.
|
[
"GetStatus",
"returns",
"the",
"status",
"of",
"the",
"cilium",
"-",
"health",
"daemon",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium-health/launch/launcher.go#L90-L95
|
162,454 |
cilium/cilium
|
cilium-health/launch/launcher.go
|
setStatus
|
func (ch *CiliumHealth) setStatus(status *models.Status) {
ch.Mutex.Lock()
ch.status = status
ch.Mutex.Unlock()
}
|
go
|
func (ch *CiliumHealth) setStatus(status *models.Status) {
ch.Mutex.Lock()
ch.status = status
ch.Mutex.Unlock()
}
|
[
"func",
"(",
"ch",
"*",
"CiliumHealth",
")",
"setStatus",
"(",
"status",
"*",
"models",
".",
"Status",
")",
"{",
"ch",
".",
"Mutex",
".",
"Lock",
"(",
")",
"\n",
"ch",
".",
"status",
"=",
"status",
"\n",
"ch",
".",
"Mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// setStatus updates the status of the cilium-health daemon.
|
[
"setStatus",
"updates",
"the",
"status",
"of",
"the",
"cilium",
"-",
"health",
"daemon",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium-health/launch/launcher.go#L98-L102
|
162,455 |
cilium/cilium
|
api/v1/server/restapi/ipam/delete_ip_a_m_ip_parameters.go
|
bindIP
|
func (o *DeleteIPAMIPParams) bindIP(rawData []string, hasKey bool, formats strfmt.Registry) error {
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
// Required: true
// Parameter is provided by construction from the route
o.IP = raw
return nil
}
|
go
|
func (o *DeleteIPAMIPParams) bindIP(rawData []string, hasKey bool, formats strfmt.Registry) error {
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
// Required: true
// Parameter is provided by construction from the route
o.IP = raw
return nil
}
|
[
"func",
"(",
"o",
"*",
"DeleteIPAMIPParams",
")",
"bindIP",
"(",
"rawData",
"[",
"]",
"string",
",",
"hasKey",
"bool",
",",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"raw",
"string",
"\n",
"if",
"len",
"(",
"rawData",
")",
">",
"0",
"{",
"raw",
"=",
"rawData",
"[",
"len",
"(",
"rawData",
")",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"// Required: true",
"// Parameter is provided by construction from the route",
"o",
".",
"IP",
"=",
"raw",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// bindIP binds and validates parameter IP from path.
|
[
"bindIP",
"binds",
"and",
"validates",
"parameter",
"IP",
"from",
"path",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/ipam/delete_ip_a_m_ip_parameters.go#L61-L73
|
162,456 |
cilium/cilium
|
api/v1/server/restapi/policy/delete_fqdn_cache_responses.go
|
WithPayload
|
func (o *DeleteFqdnCacheBadRequest) WithPayload(payload models.Error) *DeleteFqdnCacheBadRequest {
o.Payload = payload
return o
}
|
go
|
func (o *DeleteFqdnCacheBadRequest) WithPayload(payload models.Error) *DeleteFqdnCacheBadRequest {
o.Payload = payload
return o
}
|
[
"func",
"(",
"o",
"*",
"DeleteFqdnCacheBadRequest",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"DeleteFqdnCacheBadRequest",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithPayload adds the payload to the delete fqdn cache bad request response
|
[
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"delete",
"fqdn",
"cache",
"bad",
"request",
"response"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/delete_fqdn_cache_responses.go#L62-L65
|
162,457 |
cilium/cilium
|
pkg/endpoint/directory.go
|
DirectoryPath
|
func (e *Endpoint) DirectoryPath() string {
return filepath.Join(".", fmt.Sprintf("%d", e.ID))
}
|
go
|
func (e *Endpoint) DirectoryPath() string {
return filepath.Join(".", fmt.Sprintf("%d", e.ID))
}
|
[
"func",
"(",
"e",
"*",
"Endpoint",
")",
"DirectoryPath",
"(",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"ID",
")",
")",
"\n",
"}"
] |
// DirectoryPath returns the directory name for this endpoint bpf program.
|
[
"DirectoryPath",
"returns",
"the",
"directory",
"name",
"for",
"this",
"endpoint",
"bpf",
"program",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/directory.go#L30-L32
|
162,458 |
cilium/cilium
|
pkg/endpoint/directory.go
|
StateDirectoryPath
|
func (e *Endpoint) StateDirectoryPath() string {
return filepath.Join(option.Config.StateDir, e.StringID())
}
|
go
|
func (e *Endpoint) StateDirectoryPath() string {
return filepath.Join(option.Config.StateDir, e.StringID())
}
|
[
"func",
"(",
"e",
"*",
"Endpoint",
")",
"StateDirectoryPath",
"(",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"option",
".",
"Config",
".",
"StateDir",
",",
"e",
".",
"StringID",
"(",
")",
")",
"\n",
"}"
] |
// StateDirectoryPath returns the directory name for this endpoint bpf program.
|
[
"StateDirectoryPath",
"returns",
"the",
"directory",
"name",
"for",
"this",
"endpoint",
"bpf",
"program",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/directory.go#L41-L43
|
162,459 |
cilium/cilium
|
pkg/endpoint/directory.go
|
synchronizeDirectories
|
func (e *Endpoint) synchronizeDirectories(origDir string, compilationExecuted bool) error {
scopedLog := e.getLogger()
scopedLog.Debug("synchronizing directories")
tmpDir := e.NextDirectoryPath()
// Check if an existing endpoint directory exists, e.g.
// /var/run/cilium/state/1111
_, err := os.Stat(origDir)
switch {
// An endpoint directory already exists. We need to back it up before attempting
// to move the new directory in its place so we can attempt recovery.
case !os.IsNotExist(err):
scopedLog.Debug("endpoint directory exists; backing it up")
backupDir := e.backupDirectoryPath()
// Remove any eventual old backup directory. This may fail if
// the directory does not exist. The error is deliberately
// ignored.
e.removeDirectory(backupDir)
// Move the current endpoint directory to a backup location
scopedLog.WithFields(logrus.Fields{
"originalDirectory": origDir,
"backupDirectory": backupDir,
}).Debug("moving current directory to backup location")
if err := os.Rename(origDir, backupDir); err != nil {
return fmt.Errorf("unable to rename current endpoint directory: %s", err)
}
// Regarldess of whether the atomic replace succeeds or not,
// ensure that the backup directory is removed when the
// function returns.
defer e.removeDirectory(backupDir)
// Make temporary directory the new endpoint directory
if err := os.Rename(tmpDir, origDir); err != nil {
if err2 := os.Rename(backupDir, origDir); err2 != nil {
scopedLog.WithFields(logrus.Fields{
logfields.Path: backupDir,
}).Warn("restoring directory for endpoint failed, endpoint " +
"is in inconsistent state. Keeping stale directory.")
return err2
}
return fmt.Errorf("restored original endpoint directory, atomic directory move failed: %s", err)
}
// If the compilation was skipped then we need to copy the old
// bpf objects into the new directory
if !compilationExecuted {
scopedLog.Debug("compilation was skipped; moving old BPF objects into new directory")
err := common.MoveNewFilesTo(backupDir, origDir)
if err != nil {
log.WithError(err).Debugf("unable to copy old bpf object "+
"files from %s into the new directory %s.", backupDir, origDir)
}
}
// No existing endpoint directory, synchronizing the directory is a
// simple move
default:
// Make temporary directory the new endpoint directory
scopedLog.WithFields(logrus.Fields{
"temporaryDirectory": tmpDir,
"originalDirectory": origDir,
}).Debug("attempting to make temporary directory new directory for endpoint programs")
if err := os.Rename(tmpDir, origDir); err != nil {
return fmt.Errorf("atomic endpoint directory move failed: %s", err)
}
}
// The build succeeded and is in place, any eventual existing failure
// directory can be removed.
e.removeDirectory(e.FailedDirectoryPath())
return nil
}
|
go
|
func (e *Endpoint) synchronizeDirectories(origDir string, compilationExecuted bool) error {
scopedLog := e.getLogger()
scopedLog.Debug("synchronizing directories")
tmpDir := e.NextDirectoryPath()
// Check if an existing endpoint directory exists, e.g.
// /var/run/cilium/state/1111
_, err := os.Stat(origDir)
switch {
// An endpoint directory already exists. We need to back it up before attempting
// to move the new directory in its place so we can attempt recovery.
case !os.IsNotExist(err):
scopedLog.Debug("endpoint directory exists; backing it up")
backupDir := e.backupDirectoryPath()
// Remove any eventual old backup directory. This may fail if
// the directory does not exist. The error is deliberately
// ignored.
e.removeDirectory(backupDir)
// Move the current endpoint directory to a backup location
scopedLog.WithFields(logrus.Fields{
"originalDirectory": origDir,
"backupDirectory": backupDir,
}).Debug("moving current directory to backup location")
if err := os.Rename(origDir, backupDir); err != nil {
return fmt.Errorf("unable to rename current endpoint directory: %s", err)
}
// Regarldess of whether the atomic replace succeeds or not,
// ensure that the backup directory is removed when the
// function returns.
defer e.removeDirectory(backupDir)
// Make temporary directory the new endpoint directory
if err := os.Rename(tmpDir, origDir); err != nil {
if err2 := os.Rename(backupDir, origDir); err2 != nil {
scopedLog.WithFields(logrus.Fields{
logfields.Path: backupDir,
}).Warn("restoring directory for endpoint failed, endpoint " +
"is in inconsistent state. Keeping stale directory.")
return err2
}
return fmt.Errorf("restored original endpoint directory, atomic directory move failed: %s", err)
}
// If the compilation was skipped then we need to copy the old
// bpf objects into the new directory
if !compilationExecuted {
scopedLog.Debug("compilation was skipped; moving old BPF objects into new directory")
err := common.MoveNewFilesTo(backupDir, origDir)
if err != nil {
log.WithError(err).Debugf("unable to copy old bpf object "+
"files from %s into the new directory %s.", backupDir, origDir)
}
}
// No existing endpoint directory, synchronizing the directory is a
// simple move
default:
// Make temporary directory the new endpoint directory
scopedLog.WithFields(logrus.Fields{
"temporaryDirectory": tmpDir,
"originalDirectory": origDir,
}).Debug("attempting to make temporary directory new directory for endpoint programs")
if err := os.Rename(tmpDir, origDir); err != nil {
return fmt.Errorf("atomic endpoint directory move failed: %s", err)
}
}
// The build succeeded and is in place, any eventual existing failure
// directory can be removed.
e.removeDirectory(e.FailedDirectoryPath())
return nil
}
|
[
"func",
"(",
"e",
"*",
"Endpoint",
")",
"synchronizeDirectories",
"(",
"origDir",
"string",
",",
"compilationExecuted",
"bool",
")",
"error",
"{",
"scopedLog",
":=",
"e",
".",
"getLogger",
"(",
")",
"\n",
"scopedLog",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"tmpDir",
":=",
"e",
".",
"NextDirectoryPath",
"(",
")",
"\n\n",
"// Check if an existing endpoint directory exists, e.g.",
"// /var/run/cilium/state/1111",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"origDir",
")",
"\n",
"switch",
"{",
"// An endpoint directory already exists. We need to back it up before attempting",
"// to move the new directory in its place so we can attempt recovery.",
"case",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
":",
"scopedLog",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"backupDir",
":=",
"e",
".",
"backupDirectoryPath",
"(",
")",
"\n\n",
"// Remove any eventual old backup directory. This may fail if",
"// the directory does not exist. The error is deliberately",
"// ignored.",
"e",
".",
"removeDirectory",
"(",
"backupDir",
")",
"\n\n",
"// Move the current endpoint directory to a backup location",
"scopedLog",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"origDir",
",",
"\"",
"\"",
":",
"backupDir",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"origDir",
",",
"backupDir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Regarldess of whether the atomic replace succeeds or not,",
"// ensure that the backup directory is removed when the",
"// function returns.",
"defer",
"e",
".",
"removeDirectory",
"(",
"backupDir",
")",
"\n\n",
"// Make temporary directory the new endpoint directory",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"tmpDir",
",",
"origDir",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err2",
":=",
"os",
".",
"Rename",
"(",
"backupDir",
",",
"origDir",
")",
";",
"err2",
"!=",
"nil",
"{",
"scopedLog",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"Path",
":",
"backupDir",
",",
"}",
")",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
")",
"\n",
"return",
"err2",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// If the compilation was skipped then we need to copy the old",
"// bpf objects into the new directory",
"if",
"!",
"compilationExecuted",
"{",
"scopedLog",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"err",
":=",
"common",
".",
"MoveNewFilesTo",
"(",
"backupDir",
",",
"origDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Debugf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"backupDir",
",",
"origDir",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// No existing endpoint directory, synchronizing the directory is a",
"// simple move",
"default",
":",
"// Make temporary directory the new endpoint directory",
"scopedLog",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"tmpDir",
",",
"\"",
"\"",
":",
"origDir",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"tmpDir",
",",
"origDir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// The build succeeded and is in place, any eventual existing failure",
"// directory can be removed.",
"e",
".",
"removeDirectory",
"(",
"e",
".",
"FailedDirectoryPath",
"(",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// synchronizeDirectories moves the files related to endpoint BPF program
// compilation to their according directories if compilation of BPF was
// necessary for the endpoint.
// Returns the original regenerationError if regenerationError was non-nil,
// or if any updates to directories for the endpoint's directories fails.
// Must be called with endpoint.Mutex held.
|
[
"synchronizeDirectories",
"moves",
"the",
"files",
"related",
"to",
"endpoint",
"BPF",
"program",
"compilation",
"to",
"their",
"according",
"directories",
"if",
"compilation",
"of",
"BPF",
"was",
"necessary",
"for",
"the",
"endpoint",
".",
"Returns",
"the",
"original",
"regenerationError",
"if",
"regenerationError",
"was",
"non",
"-",
"nil",
"or",
"if",
"any",
"updates",
"to",
"directories",
"for",
"the",
"endpoint",
"s",
"directories",
"fails",
".",
"Must",
"be",
"called",
"with",
"endpoint",
".",
"Mutex",
"held",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/directory.go#L61-L139
|
162,460 |
cilium/cilium
|
pkg/node/node.go
|
String
|
func (nn Identity) String() string {
return path.Join(nn.Cluster, nn.Name)
}
|
go
|
func (nn Identity) String() string {
return path.Join(nn.Cluster, nn.Name)
}
|
[
"func",
"(",
"nn",
"Identity",
")",
"String",
"(",
")",
"string",
"{",
"return",
"path",
".",
"Join",
"(",
"nn",
".",
"Cluster",
",",
"nn",
".",
"Name",
")",
"\n",
"}"
] |
// String returns the string representation on NodeIdentity.
|
[
"String",
"returns",
"the",
"string",
"representation",
"on",
"NodeIdentity",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L57-L59
|
162,461 |
cilium/cilium
|
pkg/node/node.go
|
Fullname
|
func (n *Node) Fullname() string {
if n.Cluster != defaults.ClusterName {
return path.Join(n.Cluster, n.Name)
}
return n.Name
}
|
go
|
func (n *Node) Fullname() string {
if n.Cluster != defaults.ClusterName {
return path.Join(n.Cluster, n.Name)
}
return n.Name
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"Fullname",
"(",
")",
"string",
"{",
"if",
"n",
".",
"Cluster",
"!=",
"defaults",
".",
"ClusterName",
"{",
"return",
"path",
".",
"Join",
"(",
"n",
".",
"Cluster",
",",
"n",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"return",
"n",
".",
"Name",
"\n",
"}"
] |
// Fullname returns the node's full name including the cluster name if a
// cluster name value other than the default value has been specified
|
[
"Fullname",
"returns",
"the",
"node",
"s",
"full",
"name",
"including",
"the",
"cluster",
"name",
"if",
"a",
"cluster",
"name",
"value",
"other",
"than",
"the",
"default",
"value",
"has",
"been",
"specified"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L101-L107
|
162,462 |
cilium/cilium
|
pkg/node/node.go
|
GetModel
|
func (n *Node) GetModel() *models.NodeElement {
return &models.NodeElement{
Name: n.Fullname(),
PrimaryAddress: n.getPrimaryAddress(),
SecondaryAddresses: n.getSecondaryAddresses(),
HealthEndpointAddress: n.getHealthAddresses(),
}
}
|
go
|
func (n *Node) GetModel() *models.NodeElement {
return &models.NodeElement{
Name: n.Fullname(),
PrimaryAddress: n.getPrimaryAddress(),
SecondaryAddresses: n.getSecondaryAddresses(),
HealthEndpointAddress: n.getHealthAddresses(),
}
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"GetModel",
"(",
")",
"*",
"models",
".",
"NodeElement",
"{",
"return",
"&",
"models",
".",
"NodeElement",
"{",
"Name",
":",
"n",
".",
"Fullname",
"(",
")",
",",
"PrimaryAddress",
":",
"n",
".",
"getPrimaryAddress",
"(",
")",
",",
"SecondaryAddresses",
":",
"n",
".",
"getSecondaryAddresses",
"(",
")",
",",
"HealthEndpointAddress",
":",
"n",
".",
"getHealthAddresses",
"(",
")",
",",
"}",
"\n",
"}"
] |
// GetModel returns the API model representation of a node.
|
[
"GetModel",
"returns",
"the",
"API",
"model",
"representation",
"of",
"a",
"node",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L243-L250
|
162,463 |
cilium/cilium
|
pkg/node/node.go
|
Identity
|
func (n *Node) Identity() Identity {
return Identity{
Name: n.Name,
Cluster: n.Cluster,
}
}
|
go
|
func (n *Node) Identity() Identity {
return Identity{
Name: n.Name,
Cluster: n.Cluster,
}
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"Identity",
"(",
")",
"Identity",
"{",
"return",
"Identity",
"{",
"Name",
":",
"n",
".",
"Name",
",",
"Cluster",
":",
"n",
".",
"Cluster",
",",
"}",
"\n",
"}"
] |
// Identity returns the identity of the node
|
[
"Identity",
"returns",
"the",
"identity",
"of",
"the",
"node"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L253-L258
|
162,464 |
cilium/cilium
|
pkg/node/node.go
|
PublicAttrEquals
|
func (n *Node) PublicAttrEquals(o *Node) bool {
if (n == nil) != (o == nil) {
return false
}
if n.Name == o.Name &&
n.Cluster == o.Cluster &&
n.IPv4HealthIP.Equal(o.IPv4HealthIP) &&
n.IPv6HealthIP.Equal(o.IPv6HealthIP) &&
n.ClusterID == o.ClusterID &&
n.Source == o.Source {
if len(n.IPAddresses) != len(o.IPAddresses) {
return false
}
for i := range n.IPAddresses {
if (n.IPAddresses[i].Type != o.IPAddresses[i].Type) ||
!n.IPAddresses[i].IP.Equal(o.IPAddresses[i].IP) {
return false
}
}
if (n.IPv4AllocCIDR == nil) != (o.IPv4AllocCIDR == nil) {
return false
}
if n.IPv4AllocCIDR.String() != o.IPv4AllocCIDR.String() {
return false
}
if (n.IPv6AllocCIDR == nil) != (o.IPv6AllocCIDR == nil) {
return false
}
if n.IPv6AllocCIDR.String() != o.IPv6AllocCIDR.String() {
return false
}
return true
}
return false
}
|
go
|
func (n *Node) PublicAttrEquals(o *Node) bool {
if (n == nil) != (o == nil) {
return false
}
if n.Name == o.Name &&
n.Cluster == o.Cluster &&
n.IPv4HealthIP.Equal(o.IPv4HealthIP) &&
n.IPv6HealthIP.Equal(o.IPv6HealthIP) &&
n.ClusterID == o.ClusterID &&
n.Source == o.Source {
if len(n.IPAddresses) != len(o.IPAddresses) {
return false
}
for i := range n.IPAddresses {
if (n.IPAddresses[i].Type != o.IPAddresses[i].Type) ||
!n.IPAddresses[i].IP.Equal(o.IPAddresses[i].IP) {
return false
}
}
if (n.IPv4AllocCIDR == nil) != (o.IPv4AllocCIDR == nil) {
return false
}
if n.IPv4AllocCIDR.String() != o.IPv4AllocCIDR.String() {
return false
}
if (n.IPv6AllocCIDR == nil) != (o.IPv6AllocCIDR == nil) {
return false
}
if n.IPv6AllocCIDR.String() != o.IPv6AllocCIDR.String() {
return false
}
return true
}
return false
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"PublicAttrEquals",
"(",
"o",
"*",
"Node",
")",
"bool",
"{",
"if",
"(",
"n",
"==",
"nil",
")",
"!=",
"(",
"o",
"==",
"nil",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"Name",
"==",
"o",
".",
"Name",
"&&",
"n",
".",
"Cluster",
"==",
"o",
".",
"Cluster",
"&&",
"n",
".",
"IPv4HealthIP",
".",
"Equal",
"(",
"o",
".",
"IPv4HealthIP",
")",
"&&",
"n",
".",
"IPv6HealthIP",
".",
"Equal",
"(",
"o",
".",
"IPv6HealthIP",
")",
"&&",
"n",
".",
"ClusterID",
"==",
"o",
".",
"ClusterID",
"&&",
"n",
".",
"Source",
"==",
"o",
".",
"Source",
"{",
"if",
"len",
"(",
"n",
".",
"IPAddresses",
")",
"!=",
"len",
"(",
"o",
".",
"IPAddresses",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"n",
".",
"IPAddresses",
"{",
"if",
"(",
"n",
".",
"IPAddresses",
"[",
"i",
"]",
".",
"Type",
"!=",
"o",
".",
"IPAddresses",
"[",
"i",
"]",
".",
"Type",
")",
"||",
"!",
"n",
".",
"IPAddresses",
"[",
"i",
"]",
".",
"IP",
".",
"Equal",
"(",
"o",
".",
"IPAddresses",
"[",
"i",
"]",
".",
"IP",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"(",
"n",
".",
"IPv4AllocCIDR",
"==",
"nil",
")",
"!=",
"(",
"o",
".",
"IPv4AllocCIDR",
"==",
"nil",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"n",
".",
"IPv4AllocCIDR",
".",
"String",
"(",
")",
"!=",
"o",
".",
"IPv4AllocCIDR",
".",
"String",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"(",
"n",
".",
"IPv6AllocCIDR",
"==",
"nil",
")",
"!=",
"(",
"o",
".",
"IPv6AllocCIDR",
"==",
"nil",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"n",
".",
"IPv6AllocCIDR",
".",
"String",
"(",
")",
"!=",
"o",
".",
"IPv6AllocCIDR",
".",
"String",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// PublicAttrEquals returns true only if the public attributes of both nodes
// are the same otherwise returns false.
|
[
"PublicAttrEquals",
"returns",
"true",
"only",
"if",
"the",
"public",
"attributes",
"of",
"both",
"nodes",
"are",
"the",
"same",
"otherwise",
"returns",
"false",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L268-L309
|
162,465 |
cilium/cilium
|
pkg/node/node.go
|
Unmarshal
|
func (n *Node) Unmarshal(data []byte) error {
newNode := Node{}
if err := json.Unmarshal(data, &newNode); err != nil {
return err
}
*n = newNode
return nil
}
|
go
|
func (n *Node) Unmarshal(data []byte) error {
newNode := Node{}
if err := json.Unmarshal(data, &newNode); err != nil {
return err
}
*n = newNode
return nil
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"newNode",
":=",
"Node",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"newNode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"*",
"n",
"=",
"newNode",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Unmarshal parses the JSON byte slice and updates the node receiver
|
[
"Unmarshal",
"parses",
"the",
"JSON",
"byte",
"slice",
"and",
"updates",
"the",
"node",
"receiver"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/node/node.go#L334-L343
|
162,466 |
cilium/cilium
|
pkg/datapath/link/link.go
|
DeleteByName
|
func DeleteByName(ifName string) error {
iface, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup %q: %v", ifName, err)
}
if err = netlink.LinkDel(iface); err != nil {
return fmt.Errorf("failed to delete %q: %v", ifName, err)
}
return nil
}
|
go
|
func DeleteByName(ifName string) error {
iface, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup %q: %v", ifName, err)
}
if err = netlink.LinkDel(iface); err != nil {
return fmt.Errorf("failed to delete %q: %v", ifName, err)
}
return nil
}
|
[
"func",
"DeleteByName",
"(",
"ifName",
"string",
")",
"error",
"{",
"iface",
",",
"err",
":=",
"netlink",
".",
"LinkByName",
"(",
"ifName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ifName",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"netlink",
".",
"LinkDel",
"(",
"iface",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ifName",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteByName deletes the interface with the name ifName.
|
[
"DeleteByName",
"deletes",
"the",
"interface",
"with",
"the",
"name",
"ifName",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/link/link.go#L24-L35
|
162,467 |
cilium/cilium
|
pkg/datapath/link/link.go
|
Rename
|
func Rename(curName, newName string) error {
link, err := netlink.LinkByName(curName)
if err != nil {
return err
}
return netlink.LinkSetName(link, newName)
}
|
go
|
func Rename(curName, newName string) error {
link, err := netlink.LinkByName(curName)
if err != nil {
return err
}
return netlink.LinkSetName(link, newName)
}
|
[
"func",
"Rename",
"(",
"curName",
",",
"newName",
"string",
")",
"error",
"{",
"link",
",",
"err",
":=",
"netlink",
".",
"LinkByName",
"(",
"curName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"netlink",
".",
"LinkSetName",
"(",
"link",
",",
"newName",
")",
"\n",
"}"
] |
// Rename renames a network link
|
[
"Rename",
"renames",
"a",
"network",
"link"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/link/link.go#L38-L45
|
162,468 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
reverse
|
func reverse(b []byte) []byte {
size := len(b)
c := make([]byte, size)
for i, j := size-1, 0; i >= 0; i, j = i-1, j+1 {
c[j] = b[i]
}
return c
}
|
go
|
func reverse(b []byte) []byte {
size := len(b)
c := make([]byte, size)
for i, j := size-1, 0; i >= 0; i, j = i-1, j+1 {
c[j] = b[i]
}
return c
}
|
[
"func",
"reverse",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"size",
":=",
"len",
"(",
"b",
")",
"\n",
"c",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n\n",
"for",
"i",
",",
"j",
":=",
"size",
"-",
"1",
",",
"0",
";",
"i",
">=",
"0",
";",
"i",
",",
"j",
"=",
"i",
"-",
"1",
",",
"j",
"+",
"1",
"{",
"c",
"[",
"j",
"]",
"=",
"b",
"[",
"i",
"]",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"}"
] |
// reverse returns a reversed slice of b.
|
[
"reverse",
"returns",
"a",
"reversed",
"slice",
"of",
"b",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L58-L67
|
162,469 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
HostToNetwork
|
func HostToNetwork(b interface{}) interface{} {
switch b.(type) {
case uint16:
return swap16(b.(uint16))
case uint32:
return swap32(b.(uint32))
default:
panic(unsupported(b))
}
}
|
go
|
func HostToNetwork(b interface{}) interface{} {
switch b.(type) {
case uint16:
return swap16(b.(uint16))
case uint32:
return swap32(b.(uint32))
default:
panic(unsupported(b))
}
}
|
[
"func",
"HostToNetwork",
"(",
"b",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"switch",
"b",
".",
"(",
"type",
")",
"{",
"case",
"uint16",
":",
"return",
"swap16",
"(",
"b",
".",
"(",
"uint16",
")",
")",
"\n",
"case",
"uint32",
":",
"return",
"swap32",
"(",
"b",
".",
"(",
"uint32",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// HostToNetwork converts b to the networking byte order.
|
[
"HostToNetwork",
"converts",
"b",
"to",
"the",
"networking",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L70-L79
|
162,470 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
NetworkToHost
|
func NetworkToHost(n interface{}) interface{} {
switch n.(type) {
case uint16:
return swap16(n.(uint16))
case uint32:
return swap32(n.(uint32))
default:
panic(unsupported(n))
}
}
|
go
|
func NetworkToHost(n interface{}) interface{} {
switch n.(type) {
case uint16:
return swap16(n.(uint16))
case uint32:
return swap32(n.(uint32))
default:
panic(unsupported(n))
}
}
|
[
"func",
"NetworkToHost",
"(",
"n",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"switch",
"n",
".",
"(",
"type",
")",
"{",
"case",
"uint16",
":",
"return",
"swap16",
"(",
"n",
".",
"(",
"uint16",
")",
")",
"\n",
"case",
"uint32",
":",
"return",
"swap32",
"(",
"n",
".",
"(",
"uint32",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"n",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// NetworkToHost converts n to host byte order.
|
[
"NetworkToHost",
"converts",
"n",
"to",
"host",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L82-L91
|
162,471 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
HostToNetworkSlice
|
func HostToNetworkSlice(b []byte, t reflect.Kind) interface{} {
switch t {
case reflect.Uint32:
return binary.BigEndian.Uint32(b)
case reflect.Uint16:
return binary.BigEndian.Uint16(b)
default:
panic(unsupported(b))
}
}
|
go
|
func HostToNetworkSlice(b []byte, t reflect.Kind) interface{} {
switch t {
case reflect.Uint32:
return binary.BigEndian.Uint32(b)
case reflect.Uint16:
return binary.BigEndian.Uint16(b)
default:
panic(unsupported(b))
}
}
|
[
"func",
"HostToNetworkSlice",
"(",
"b",
"[",
"]",
"byte",
",",
"t",
"reflect",
".",
"Kind",
")",
"interface",
"{",
"}",
"{",
"switch",
"t",
"{",
"case",
"reflect",
".",
"Uint32",
":",
"return",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"b",
")",
"\n",
"case",
"reflect",
".",
"Uint16",
":",
"return",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"b",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// HostToNetworkSlice converts b to the networking byte order.
|
[
"HostToNetworkSlice",
"converts",
"b",
"to",
"the",
"networking",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L94-L103
|
162,472 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
HostToNetworkPut
|
func HostToNetworkPut(b []byte, v interface{}) {
switch reflect.TypeOf(v).Kind() {
case reflect.Uint32:
binary.BigEndian.PutUint32(b, v.(uint32))
case reflect.Uint16:
binary.BigEndian.PutUint16(b, v.(uint16))
default:
panic(unsupported(v))
}
}
|
go
|
func HostToNetworkPut(b []byte, v interface{}) {
switch reflect.TypeOf(v).Kind() {
case reflect.Uint32:
binary.BigEndian.PutUint32(b, v.(uint32))
case reflect.Uint16:
binary.BigEndian.PutUint16(b, v.(uint16))
default:
panic(unsupported(v))
}
}
|
[
"func",
"HostToNetworkPut",
"(",
"b",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"{",
"switch",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Uint32",
":",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"b",
",",
"v",
".",
"(",
"uint32",
")",
")",
"\n",
"case",
"reflect",
".",
"Uint16",
":",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"b",
",",
"v",
".",
"(",
"uint16",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// HostToNetworkPut puts v into b with the networking byte order.
|
[
"HostToNetworkPut",
"puts",
"v",
"into",
"b",
"with",
"the",
"networking",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L106-L115
|
162,473 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
NetworkToHostPut
|
func NetworkToHostPut(b []byte, v interface{}) {
switch reflect.TypeOf(v).Kind() {
case reflect.Uint32:
Native.PutUint32(b, v.(uint32))
case reflect.Uint16:
Native.PutUint16(b, v.(uint16))
default:
panic(unsupported(v))
}
}
|
go
|
func NetworkToHostPut(b []byte, v interface{}) {
switch reflect.TypeOf(v).Kind() {
case reflect.Uint32:
Native.PutUint32(b, v.(uint32))
case reflect.Uint16:
Native.PutUint16(b, v.(uint16))
default:
panic(unsupported(v))
}
}
|
[
"func",
"NetworkToHostPut",
"(",
"b",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"{",
"switch",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Uint32",
":",
"Native",
".",
"PutUint32",
"(",
"b",
",",
"v",
".",
"(",
"uint32",
")",
")",
"\n",
"case",
"reflect",
".",
"Uint16",
":",
"Native",
".",
"PutUint16",
"(",
"b",
",",
"v",
".",
"(",
"uint16",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// NetworkToHostPut puts v into b with the networking byte order.
|
[
"NetworkToHostPut",
"puts",
"v",
"into",
"b",
"with",
"the",
"networking",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L118-L127
|
162,474 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
HostSliceToNetwork
|
func HostSliceToNetwork(b []byte, t reflect.Kind) interface{} {
switch t {
case reflect.Uint32:
if Native != binary.BigEndian {
return binary.BigEndian.Uint32(reverse(b))
}
return binary.BigEndian.Uint32(b)
case reflect.Uint16:
if Native != binary.BigEndian {
return binary.BigEndian.Uint16(reverse(b))
}
return binary.BigEndian.Uint16(b)
default:
panic(unsupported(t))
}
}
|
go
|
func HostSliceToNetwork(b []byte, t reflect.Kind) interface{} {
switch t {
case reflect.Uint32:
if Native != binary.BigEndian {
return binary.BigEndian.Uint32(reverse(b))
}
return binary.BigEndian.Uint32(b)
case reflect.Uint16:
if Native != binary.BigEndian {
return binary.BigEndian.Uint16(reverse(b))
}
return binary.BigEndian.Uint16(b)
default:
panic(unsupported(t))
}
}
|
[
"func",
"HostSliceToNetwork",
"(",
"b",
"[",
"]",
"byte",
",",
"t",
"reflect",
".",
"Kind",
")",
"interface",
"{",
"}",
"{",
"switch",
"t",
"{",
"case",
"reflect",
".",
"Uint32",
":",
"if",
"Native",
"!=",
"binary",
".",
"BigEndian",
"{",
"return",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"reverse",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"return",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"b",
")",
"\n",
"case",
"reflect",
".",
"Uint16",
":",
"if",
"Native",
"!=",
"binary",
".",
"BigEndian",
"{",
"return",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"reverse",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"return",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"b",
")",
"\n",
"default",
":",
"panic",
"(",
"unsupported",
"(",
"t",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// HostSliceToNetwork converts b to the networking byte order.
|
[
"HostSliceToNetwork",
"converts",
"b",
"to",
"the",
"networking",
"byte",
"order",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L130-L145
|
162,475 |
cilium/cilium
|
pkg/byteorder/byteorder.go
|
unsupported
|
func unsupported(field interface{}) string {
return fmt.Sprintf("unsupported type(%v): %v", reflect.TypeOf(field).Kind(), field)
}
|
go
|
func unsupported(field interface{}) string {
return fmt.Sprintf("unsupported type(%v): %v", reflect.TypeOf(field).Kind(), field)
}
|
[
"func",
"unsupported",
"(",
"field",
"interface",
"{",
"}",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"field",
")",
".",
"Kind",
"(",
")",
",",
"field",
")",
"\n",
"}"
] |
// unsupported returns a string to used for debugging unhandled types.
|
[
"unsupported",
"returns",
"a",
"string",
"to",
"used",
"for",
"debugging",
"unhandled",
"types",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/byteorder/byteorder.go#L148-L150
|
162,476 |
cilium/cilium
|
api/v1/health/models/health_status_response.go
|
Validate
|
func (m *HealthStatusResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLocal(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodes(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
go
|
func (m *HealthStatusResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLocal(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodes(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"HealthStatusResponse",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateLocal",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateNodes",
"(",
"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 health status response
|
[
"Validate",
"validates",
"this",
"health",
"status",
"response"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/health_status_response.go#L32-L47
|
162,477 |
cilium/cilium
|
api/v1/server/restapi/policy/get_policy_responses.go
|
WithPayload
|
func (o *GetPolicyOK) WithPayload(payload *models.Policy) *GetPolicyOK {
o.Payload = payload
return o
}
|
go
|
func (o *GetPolicyOK) WithPayload(payload *models.Policy) *GetPolicyOK {
o.Payload = payload
return o
}
|
[
"func",
"(",
"o",
"*",
"GetPolicyOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"Policy",
")",
"*",
"GetPolicyOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithPayload adds the payload to the get policy o k response
|
[
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"policy",
"o",
"k",
"response"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_policy_responses.go#L38-L41
|
162,478 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
NewServiceCache
|
func NewServiceCache() ServiceCache {
return ServiceCache{
services: map[ServiceID]*Service{},
endpoints: map[ServiceID]*Endpoints{},
ingresses: map[ServiceID]*Service{},
externalEndpoints: map[ServiceID]externalEndpoints{},
Events: make(chan ServiceEvent, 128),
}
}
|
go
|
func NewServiceCache() ServiceCache {
return ServiceCache{
services: map[ServiceID]*Service{},
endpoints: map[ServiceID]*Endpoints{},
ingresses: map[ServiceID]*Service{},
externalEndpoints: map[ServiceID]externalEndpoints{},
Events: make(chan ServiceEvent, 128),
}
}
|
[
"func",
"NewServiceCache",
"(",
")",
"ServiceCache",
"{",
"return",
"ServiceCache",
"{",
"services",
":",
"map",
"[",
"ServiceID",
"]",
"*",
"Service",
"{",
"}",
",",
"endpoints",
":",
"map",
"[",
"ServiceID",
"]",
"*",
"Endpoints",
"{",
"}",
",",
"ingresses",
":",
"map",
"[",
"ServiceID",
"]",
"*",
"Service",
"{",
"}",
",",
"externalEndpoints",
":",
"map",
"[",
"ServiceID",
"]",
"externalEndpoints",
"{",
"}",
",",
"Events",
":",
"make",
"(",
"chan",
"ServiceEvent",
",",
"128",
")",
",",
"}",
"\n",
"}"
] |
// NewServiceCache returns a new ServiceCache
|
[
"NewServiceCache",
"returns",
"a",
"new",
"ServiceCache"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L98-L106
|
162,479 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
GetRandomBackendIP
|
func (s *ServiceCache) GetRandomBackendIP(svcID ServiceID) *loadbalancer.L3n4Addr {
s.mutex.RLock()
defer s.mutex.RUnlock()
svc := s.services[svcID]
if svc == nil {
return nil
}
for _, port := range svc.Ports {
return loadbalancer.NewL3n4Addr(port.Protocol, svc.FrontendIP, port.Port)
}
return nil
}
|
go
|
func (s *ServiceCache) GetRandomBackendIP(svcID ServiceID) *loadbalancer.L3n4Addr {
s.mutex.RLock()
defer s.mutex.RUnlock()
svc := s.services[svcID]
if svc == nil {
return nil
}
for _, port := range svc.Ports {
return loadbalancer.NewL3n4Addr(port.Protocol, svc.FrontendIP, port.Port)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"GetRandomBackendIP",
"(",
"svcID",
"ServiceID",
")",
"*",
"loadbalancer",
".",
"L3n4Addr",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"svc",
":=",
"s",
".",
"services",
"[",
"svcID",
"]",
"\n",
"if",
"svc",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"port",
":=",
"range",
"svc",
".",
"Ports",
"{",
"return",
"loadbalancer",
".",
"NewL3n4Addr",
"(",
"port",
".",
"Protocol",
",",
"svc",
".",
"FrontendIP",
",",
"port",
".",
"Port",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// GetRandomBackendIP returns a random L3n4Addr that is backing the given Service ID.
|
[
"GetRandomBackendIP",
"returns",
"a",
"random",
"L3n4Addr",
"that",
"is",
"backing",
"the",
"given",
"Service",
"ID",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L109-L120
|
162,480 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
UpdateService
|
func (s *ServiceCache) UpdateService(k8sSvc *types.Service) ServiceID {
svcID, newService := ParseService(k8sSvc)
if newService == nil {
return svcID
}
s.mutex.Lock()
defer s.mutex.Unlock()
if oldService, ok := s.services[svcID]; ok {
if oldService.DeepEquals(newService) {
return svcID
}
}
s.services[svcID] = newService
// Check if the corresponding Endpoints resource is already available
endpoints, serviceReady := s.correlateEndpoints(svcID)
if serviceReady {
s.Events <- ServiceEvent{
Action: UpdateService,
ID: svcID,
Service: newService,
Endpoints: endpoints,
}
}
return svcID
}
|
go
|
func (s *ServiceCache) UpdateService(k8sSvc *types.Service) ServiceID {
svcID, newService := ParseService(k8sSvc)
if newService == nil {
return svcID
}
s.mutex.Lock()
defer s.mutex.Unlock()
if oldService, ok := s.services[svcID]; ok {
if oldService.DeepEquals(newService) {
return svcID
}
}
s.services[svcID] = newService
// Check if the corresponding Endpoints resource is already available
endpoints, serviceReady := s.correlateEndpoints(svcID)
if serviceReady {
s.Events <- ServiceEvent{
Action: UpdateService,
ID: svcID,
Service: newService,
Endpoints: endpoints,
}
}
return svcID
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"UpdateService",
"(",
"k8sSvc",
"*",
"types",
".",
"Service",
")",
"ServiceID",
"{",
"svcID",
",",
"newService",
":=",
"ParseService",
"(",
"k8sSvc",
")",
"\n",
"if",
"newService",
"==",
"nil",
"{",
"return",
"svcID",
"\n",
"}",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"oldService",
",",
"ok",
":=",
"s",
".",
"services",
"[",
"svcID",
"]",
";",
"ok",
"{",
"if",
"oldService",
".",
"DeepEquals",
"(",
"newService",
")",
"{",
"return",
"svcID",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"services",
"[",
"svcID",
"]",
"=",
"newService",
"\n\n",
"// Check if the corresponding Endpoints resource is already available",
"endpoints",
",",
"serviceReady",
":=",
"s",
".",
"correlateEndpoints",
"(",
"svcID",
")",
"\n",
"if",
"serviceReady",
"{",
"s",
".",
"Events",
"<-",
"ServiceEvent",
"{",
"Action",
":",
"UpdateService",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"newService",
",",
"Endpoints",
":",
"endpoints",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"svcID",
"\n",
"}"
] |
// UpdateService parses a Kubernetes service and adds or updates it in the
// ServiceCache. Returns the ServiceID unless the Kubernetes service could not
// be parsed and a bool to indicate whether the service was changed in the
// cache or not.
|
[
"UpdateService",
"parses",
"a",
"Kubernetes",
"service",
"and",
"adds",
"or",
"updates",
"it",
"in",
"the",
"ServiceCache",
".",
"Returns",
"the",
"ServiceID",
"unless",
"the",
"Kubernetes",
"service",
"could",
"not",
"be",
"parsed",
"and",
"a",
"bool",
"to",
"indicate",
"whether",
"the",
"service",
"was",
"changed",
"in",
"the",
"cache",
"or",
"not",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L126-L155
|
162,481 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
DeleteService
|
func (s *ServiceCache) DeleteService(k8sSvc *types.Service) {
svcID := ParseServiceID(k8sSvc)
s.mutex.Lock()
oldService, serviceOK := s.services[svcID]
endpoints, _ := s.correlateEndpoints(svcID)
delete(s.services, svcID)
s.mutex.Unlock()
if serviceOK {
s.Events <- ServiceEvent{
Action: DeleteService,
ID: svcID,
Service: oldService,
Endpoints: endpoints,
}
}
}
|
go
|
func (s *ServiceCache) DeleteService(k8sSvc *types.Service) {
svcID := ParseServiceID(k8sSvc)
s.mutex.Lock()
oldService, serviceOK := s.services[svcID]
endpoints, _ := s.correlateEndpoints(svcID)
delete(s.services, svcID)
s.mutex.Unlock()
if serviceOK {
s.Events <- ServiceEvent{
Action: DeleteService,
ID: svcID,
Service: oldService,
Endpoints: endpoints,
}
}
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"DeleteService",
"(",
"k8sSvc",
"*",
"types",
".",
"Service",
")",
"{",
"svcID",
":=",
"ParseServiceID",
"(",
"k8sSvc",
")",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"oldService",
",",
"serviceOK",
":=",
"s",
".",
"services",
"[",
"svcID",
"]",
"\n",
"endpoints",
",",
"_",
":=",
"s",
".",
"correlateEndpoints",
"(",
"svcID",
")",
"\n",
"delete",
"(",
"s",
".",
"services",
",",
"svcID",
")",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"serviceOK",
"{",
"s",
".",
"Events",
"<-",
"ServiceEvent",
"{",
"Action",
":",
"DeleteService",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"oldService",
",",
"Endpoints",
":",
"endpoints",
",",
"}",
"\n",
"}",
"\n",
"}"
] |
// DeleteService parses a Kubernetes service and removes it from the
// ServiceCache
|
[
"DeleteService",
"parses",
"a",
"Kubernetes",
"service",
"and",
"removes",
"it",
"from",
"the",
"ServiceCache"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L159-L176
|
162,482 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
UpdateEndpoints
|
func (s *ServiceCache) UpdateEndpoints(k8sEndpoints *types.Endpoints) (ServiceID, *Endpoints) {
svcID, newEndpoints := ParseEndpoints(k8sEndpoints)
s.mutex.Lock()
defer s.mutex.Unlock()
if oldEndpoints, ok := s.endpoints[svcID]; ok {
if oldEndpoints.DeepEquals(newEndpoints) {
return svcID, newEndpoints
}
}
s.endpoints[svcID] = newEndpoints
// Check if the corresponding Endpoints resource is already available
service, ok := s.services[svcID]
endpoints, serviceReady := s.correlateEndpoints(svcID)
if ok && serviceReady {
s.Events <- ServiceEvent{
Action: UpdateService,
ID: svcID,
Service: service,
Endpoints: endpoints,
}
}
return svcID, newEndpoints
}
|
go
|
func (s *ServiceCache) UpdateEndpoints(k8sEndpoints *types.Endpoints) (ServiceID, *Endpoints) {
svcID, newEndpoints := ParseEndpoints(k8sEndpoints)
s.mutex.Lock()
defer s.mutex.Unlock()
if oldEndpoints, ok := s.endpoints[svcID]; ok {
if oldEndpoints.DeepEquals(newEndpoints) {
return svcID, newEndpoints
}
}
s.endpoints[svcID] = newEndpoints
// Check if the corresponding Endpoints resource is already available
service, ok := s.services[svcID]
endpoints, serviceReady := s.correlateEndpoints(svcID)
if ok && serviceReady {
s.Events <- ServiceEvent{
Action: UpdateService,
ID: svcID,
Service: service,
Endpoints: endpoints,
}
}
return svcID, newEndpoints
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"UpdateEndpoints",
"(",
"k8sEndpoints",
"*",
"types",
".",
"Endpoints",
")",
"(",
"ServiceID",
",",
"*",
"Endpoints",
")",
"{",
"svcID",
",",
"newEndpoints",
":=",
"ParseEndpoints",
"(",
"k8sEndpoints",
")",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"oldEndpoints",
",",
"ok",
":=",
"s",
".",
"endpoints",
"[",
"svcID",
"]",
";",
"ok",
"{",
"if",
"oldEndpoints",
".",
"DeepEquals",
"(",
"newEndpoints",
")",
"{",
"return",
"svcID",
",",
"newEndpoints",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"endpoints",
"[",
"svcID",
"]",
"=",
"newEndpoints",
"\n\n",
"// Check if the corresponding Endpoints resource is already available",
"service",
",",
"ok",
":=",
"s",
".",
"services",
"[",
"svcID",
"]",
"\n",
"endpoints",
",",
"serviceReady",
":=",
"s",
".",
"correlateEndpoints",
"(",
"svcID",
")",
"\n",
"if",
"ok",
"&&",
"serviceReady",
"{",
"s",
".",
"Events",
"<-",
"ServiceEvent",
"{",
"Action",
":",
"UpdateService",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"service",
",",
"Endpoints",
":",
"endpoints",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"svcID",
",",
"newEndpoints",
"\n",
"}"
] |
// UpdateEndpoints parses a Kubernetes endpoints and adds or updates it in the
// ServiceCache. Returns the ServiceID unless the Kubernetes endpoints could not
// be parsed and a bool to indicate whether the endpoints was changed in the
// cache or not.
|
[
"UpdateEndpoints",
"parses",
"a",
"Kubernetes",
"endpoints",
"and",
"adds",
"or",
"updates",
"it",
"in",
"the",
"ServiceCache",
".",
"Returns",
"the",
"ServiceID",
"unless",
"the",
"Kubernetes",
"endpoints",
"could",
"not",
"be",
"parsed",
"and",
"a",
"bool",
"to",
"indicate",
"whether",
"the",
"endpoints",
"was",
"changed",
"in",
"the",
"cache",
"or",
"not",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L182-L209
|
162,483 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
DeleteEndpoints
|
func (s *ServiceCache) DeleteEndpoints(k8sEndpoints *types.Endpoints) ServiceID {
svcID := ParseEndpointsID(k8sEndpoints)
s.mutex.Lock()
service, serviceOK := s.services[svcID]
delete(s.endpoints, svcID)
endpoints, serviceReady := s.correlateEndpoints(svcID)
s.mutex.Unlock()
if serviceOK {
event := ServiceEvent{
Action: DeleteService,
ID: svcID,
Service: service,
Endpoints: endpoints,
}
if serviceReady {
event.Action = UpdateService
}
s.Events <- event
}
return svcID
}
|
go
|
func (s *ServiceCache) DeleteEndpoints(k8sEndpoints *types.Endpoints) ServiceID {
svcID := ParseEndpointsID(k8sEndpoints)
s.mutex.Lock()
service, serviceOK := s.services[svcID]
delete(s.endpoints, svcID)
endpoints, serviceReady := s.correlateEndpoints(svcID)
s.mutex.Unlock()
if serviceOK {
event := ServiceEvent{
Action: DeleteService,
ID: svcID,
Service: service,
Endpoints: endpoints,
}
if serviceReady {
event.Action = UpdateService
}
s.Events <- event
}
return svcID
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"DeleteEndpoints",
"(",
"k8sEndpoints",
"*",
"types",
".",
"Endpoints",
")",
"ServiceID",
"{",
"svcID",
":=",
"ParseEndpointsID",
"(",
"k8sEndpoints",
")",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"service",
",",
"serviceOK",
":=",
"s",
".",
"services",
"[",
"svcID",
"]",
"\n",
"delete",
"(",
"s",
".",
"endpoints",
",",
"svcID",
")",
"\n",
"endpoints",
",",
"serviceReady",
":=",
"s",
".",
"correlateEndpoints",
"(",
"svcID",
")",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"serviceOK",
"{",
"event",
":=",
"ServiceEvent",
"{",
"Action",
":",
"DeleteService",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"service",
",",
"Endpoints",
":",
"endpoints",
",",
"}",
"\n\n",
"if",
"serviceReady",
"{",
"event",
".",
"Action",
"=",
"UpdateService",
"\n",
"}",
"\n\n",
"s",
".",
"Events",
"<-",
"event",
"\n",
"}",
"\n\n",
"return",
"svcID",
"\n",
"}"
] |
// DeleteEndpoints parses a Kubernetes endpoints and removes it from the
// ServiceCache
|
[
"DeleteEndpoints",
"parses",
"a",
"Kubernetes",
"endpoints",
"and",
"removes",
"it",
"from",
"the",
"ServiceCache"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L213-L238
|
162,484 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
UpdateIngress
|
func (s *ServiceCache) UpdateIngress(ingress *types.Ingress, host net.IP) (ServiceID, error) {
svcID, newService, err := ParseIngress(ingress, host)
if err != nil {
return svcID, err
}
s.mutex.Lock()
defer s.mutex.Unlock()
if oldService, ok := s.ingresses[svcID]; ok {
if oldService.DeepEquals(newService) {
return svcID, nil
}
}
s.ingresses[svcID] = newService
s.Events <- ServiceEvent{
Action: UpdateIngress,
ID: svcID,
Service: newService,
}
return svcID, nil
}
|
go
|
func (s *ServiceCache) UpdateIngress(ingress *types.Ingress, host net.IP) (ServiceID, error) {
svcID, newService, err := ParseIngress(ingress, host)
if err != nil {
return svcID, err
}
s.mutex.Lock()
defer s.mutex.Unlock()
if oldService, ok := s.ingresses[svcID]; ok {
if oldService.DeepEquals(newService) {
return svcID, nil
}
}
s.ingresses[svcID] = newService
s.Events <- ServiceEvent{
Action: UpdateIngress,
ID: svcID,
Service: newService,
}
return svcID, nil
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"UpdateIngress",
"(",
"ingress",
"*",
"types",
".",
"Ingress",
",",
"host",
"net",
".",
"IP",
")",
"(",
"ServiceID",
",",
"error",
")",
"{",
"svcID",
",",
"newService",
",",
"err",
":=",
"ParseIngress",
"(",
"ingress",
",",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"svcID",
",",
"err",
"\n",
"}",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"oldService",
",",
"ok",
":=",
"s",
".",
"ingresses",
"[",
"svcID",
"]",
";",
"ok",
"{",
"if",
"oldService",
".",
"DeepEquals",
"(",
"newService",
")",
"{",
"return",
"svcID",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"ingresses",
"[",
"svcID",
"]",
"=",
"newService",
"\n\n",
"s",
".",
"Events",
"<-",
"ServiceEvent",
"{",
"Action",
":",
"UpdateIngress",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"newService",
",",
"}",
"\n\n",
"return",
"svcID",
",",
"nil",
"\n",
"}"
] |
// UpdateIngress parses a Kubernetes ingress and adds or updates it in the
// ServiceCache.
|
[
"UpdateIngress",
"parses",
"a",
"Kubernetes",
"ingress",
"and",
"adds",
"or",
"updates",
"it",
"in",
"the",
"ServiceCache",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L242-L266
|
162,485 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
DeleteIngress
|
func (s *ServiceCache) DeleteIngress(ingress *types.Ingress) {
svcID := ParseIngressID(ingress)
s.mutex.Lock()
oldService, ok := s.ingresses[svcID]
endpoints, _ := s.endpoints[svcID]
delete(s.ingresses, svcID)
s.mutex.Unlock()
if ok {
s.Events <- ServiceEvent{
Action: DeleteIngress,
ID: svcID,
Service: oldService,
Endpoints: endpoints,
}
}
}
|
go
|
func (s *ServiceCache) DeleteIngress(ingress *types.Ingress) {
svcID := ParseIngressID(ingress)
s.mutex.Lock()
oldService, ok := s.ingresses[svcID]
endpoints, _ := s.endpoints[svcID]
delete(s.ingresses, svcID)
s.mutex.Unlock()
if ok {
s.Events <- ServiceEvent{
Action: DeleteIngress,
ID: svcID,
Service: oldService,
Endpoints: endpoints,
}
}
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"DeleteIngress",
"(",
"ingress",
"*",
"types",
".",
"Ingress",
")",
"{",
"svcID",
":=",
"ParseIngressID",
"(",
"ingress",
")",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"oldService",
",",
"ok",
":=",
"s",
".",
"ingresses",
"[",
"svcID",
"]",
"\n",
"endpoints",
",",
"_",
":=",
"s",
".",
"endpoints",
"[",
"svcID",
"]",
"\n",
"delete",
"(",
"s",
".",
"ingresses",
",",
"svcID",
")",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"ok",
"{",
"s",
".",
"Events",
"<-",
"ServiceEvent",
"{",
"Action",
":",
"DeleteIngress",
",",
"ID",
":",
"svcID",
",",
"Service",
":",
"oldService",
",",
"Endpoints",
":",
"endpoints",
",",
"}",
"\n",
"}",
"\n",
"}"
] |
// DeleteIngress parses a Kubernetes ingress and removes it from the
// ServiceCache
|
[
"DeleteIngress",
"parses",
"a",
"Kubernetes",
"ingress",
"and",
"removes",
"it",
"from",
"the",
"ServiceCache"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L270-L287
|
162,486 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
LooseMatch
|
func (l FrontendList) LooseMatch(frontend loadbalancer.L3n4Addr) (exists bool) {
switch frontend.Protocol {
case loadbalancer.NONE:
for _, protocol := range loadbalancer.AllProtocols {
frontend.Protocol = protocol
_, exists = l[frontend.StringWithProtocol()]
if exists {
return
}
}
// If the protocol is set, perform an exact match
default:
_, exists = l[frontend.StringWithProtocol()]
}
return
}
|
go
|
func (l FrontendList) LooseMatch(frontend loadbalancer.L3n4Addr) (exists bool) {
switch frontend.Protocol {
case loadbalancer.NONE:
for _, protocol := range loadbalancer.AllProtocols {
frontend.Protocol = protocol
_, exists = l[frontend.StringWithProtocol()]
if exists {
return
}
}
// If the protocol is set, perform an exact match
default:
_, exists = l[frontend.StringWithProtocol()]
}
return
}
|
[
"func",
"(",
"l",
"FrontendList",
")",
"LooseMatch",
"(",
"frontend",
"loadbalancer",
".",
"L3n4Addr",
")",
"(",
"exists",
"bool",
")",
"{",
"switch",
"frontend",
".",
"Protocol",
"{",
"case",
"loadbalancer",
".",
"NONE",
":",
"for",
"_",
",",
"protocol",
":=",
"range",
"loadbalancer",
".",
"AllProtocols",
"{",
"frontend",
".",
"Protocol",
"=",
"protocol",
"\n",
"_",
",",
"exists",
"=",
"l",
"[",
"frontend",
".",
"StringWithProtocol",
"(",
")",
"]",
"\n",
"if",
"exists",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If the protocol is set, perform an exact match",
"default",
":",
"_",
",",
"exists",
"=",
"l",
"[",
"frontend",
".",
"StringWithProtocol",
"(",
")",
"]",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// LooseMatch returns true if the provided frontend is found in the
// FrontendList. If the frontend has a protocol value set, it only matches a
// k8s service with a matching protocol. If no protocol is set, any k8s service
// matching frontend IP and port is considered a match, regardless of protocol.
|
[
"LooseMatch",
"returns",
"true",
"if",
"the",
"provided",
"frontend",
"is",
"found",
"in",
"the",
"FrontendList",
".",
"If",
"the",
"frontend",
"has",
"a",
"protocol",
"value",
"set",
"it",
"only",
"matches",
"a",
"k8s",
"service",
"with",
"a",
"matching",
"protocol",
".",
"If",
"no",
"protocol",
"is",
"set",
"any",
"k8s",
"service",
"matching",
"frontend",
"IP",
"and",
"port",
"is",
"considered",
"a",
"match",
"regardless",
"of",
"protocol",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L296-L312
|
162,487 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
UniqueServiceFrontends
|
func (s *ServiceCache) UniqueServiceFrontends() FrontendList {
uniqueFrontends := FrontendList{}
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, svc := range s.services {
for _, p := range svc.Ports {
address := loadbalancer.L3n4Addr{
IP: svc.FrontendIP,
L4Addr: *p.L4Addr,
}
uniqueFrontends[address.StringWithProtocol()] = struct{}{}
}
}
return uniqueFrontends
}
|
go
|
func (s *ServiceCache) UniqueServiceFrontends() FrontendList {
uniqueFrontends := FrontendList{}
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, svc := range s.services {
for _, p := range svc.Ports {
address := loadbalancer.L3n4Addr{
IP: svc.FrontendIP,
L4Addr: *p.L4Addr,
}
uniqueFrontends[address.StringWithProtocol()] = struct{}{}
}
}
return uniqueFrontends
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"UniqueServiceFrontends",
"(",
")",
"FrontendList",
"{",
"uniqueFrontends",
":=",
"FrontendList",
"{",
"}",
"\n\n",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"svc",
":=",
"range",
"s",
".",
"services",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"svc",
".",
"Ports",
"{",
"address",
":=",
"loadbalancer",
".",
"L3n4Addr",
"{",
"IP",
":",
"svc",
".",
"FrontendIP",
",",
"L4Addr",
":",
"*",
"p",
".",
"L4Addr",
",",
"}",
"\n\n",
"uniqueFrontends",
"[",
"address",
".",
"StringWithProtocol",
"(",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"uniqueFrontends",
"\n",
"}"
] |
// UniqueServiceFrontends returns all services known to the service cache as a
// map, indexed by the string representation of a loadbalancer.L3n4Addr
|
[
"UniqueServiceFrontends",
"returns",
"all",
"services",
"known",
"to",
"the",
"service",
"cache",
"as",
"a",
"map",
"indexed",
"by",
"the",
"string",
"representation",
"of",
"a",
"loadbalancer",
".",
"L3n4Addr"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L316-L334
|
162,488 |
cilium/cilium
|
pkg/k8s/service_cache.go
|
DebugStatus
|
func (s *ServiceCache) DebugStatus() string {
s.mutex.RLock()
str := spew.Sdump(s)
s.mutex.RUnlock()
return str
}
|
go
|
func (s *ServiceCache) DebugStatus() string {
s.mutex.RLock()
str := spew.Sdump(s)
s.mutex.RUnlock()
return str
}
|
[
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"DebugStatus",
"(",
")",
"string",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"str",
":=",
"spew",
".",
"Sdump",
"(",
"s",
")",
"\n",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"str",
"\n",
"}"
] |
// DebugStatus implements debug.StatusObject to provide debug status collection
// ability
|
[
"DebugStatus",
"implements",
"debug",
".",
"StatusObject",
"to",
"provide",
"debug",
"status",
"collection",
"ability"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service_cache.go#L478-L483
|
162,489 |
cilium/cilium
|
api/v1/server/restapi/endpoint/get_endpoint_id_healthz.go
|
NewGetEndpointIDHealthz
|
func NewGetEndpointIDHealthz(ctx *middleware.Context, handler GetEndpointIDHealthzHandler) *GetEndpointIDHealthz {
return &GetEndpointIDHealthz{Context: ctx, Handler: handler}
}
|
go
|
func NewGetEndpointIDHealthz(ctx *middleware.Context, handler GetEndpointIDHealthzHandler) *GetEndpointIDHealthz {
return &GetEndpointIDHealthz{Context: ctx, Handler: handler}
}
|
[
"func",
"NewGetEndpointIDHealthz",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetEndpointIDHealthzHandler",
")",
"*",
"GetEndpointIDHealthz",
"{",
"return",
"&",
"GetEndpointIDHealthz",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] |
// NewGetEndpointIDHealthz creates a new http.Handler for the get endpoint ID healthz operation
|
[
"NewGetEndpointIDHealthz",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"endpoint",
"ID",
"healthz",
"operation"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/get_endpoint_id_healthz.go#L28-L30
|
162,490 |
cilium/cilium
|
api/v1/health/server/restapi/connectivity/get_status_responses.go
|
WithPayload
|
func (o *GetStatusOK) WithPayload(payload *models.HealthStatusResponse) *GetStatusOK {
o.Payload = payload
return o
}
|
go
|
func (o *GetStatusOK) WithPayload(payload *models.HealthStatusResponse) *GetStatusOK {
o.Payload = payload
return o
}
|
[
"func",
"(",
"o",
"*",
"GetStatusOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"HealthStatusResponse",
")",
"*",
"GetStatusOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] |
// WithPayload adds the payload to the get status o k response
|
[
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"status",
"o",
"k",
"response"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/server/restapi/connectivity/get_status_responses.go#L38-L41
|
162,491 |
cilium/cilium
|
pkg/bpf/prog_linux.go
|
GetProgNextID
|
func GetProgNextID(current uint32) (uint32, error) {
attr := attrProg{
progID: current,
}
duration := spanstat.Start()
ret, _, err := unix.Syscall(unix.SYS_BPF, BPF_PROG_GET_NEXT_ID, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
metricSyscallDuration.WithLabelValues(metricOpProgGetNextID, metrics.Errno2Outcome(err)).Observe(duration.End(err == 0).Total().Seconds())
if ret != 0 || err != 0 {
return 0, fmt.Errorf("Unable to get next id: %v", err)
}
return attr.nextID, nil
}
|
go
|
func GetProgNextID(current uint32) (uint32, error) {
attr := attrProg{
progID: current,
}
duration := spanstat.Start()
ret, _, err := unix.Syscall(unix.SYS_BPF, BPF_PROG_GET_NEXT_ID, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
metricSyscallDuration.WithLabelValues(metricOpProgGetNextID, metrics.Errno2Outcome(err)).Observe(duration.End(err == 0).Total().Seconds())
if ret != 0 || err != 0 {
return 0, fmt.Errorf("Unable to get next id: %v", err)
}
return attr.nextID, nil
}
|
[
"func",
"GetProgNextID",
"(",
"current",
"uint32",
")",
"(",
"uint32",
",",
"error",
")",
"{",
"attr",
":=",
"attrProg",
"{",
"progID",
":",
"current",
",",
"}",
"\n\n",
"duration",
":=",
"spanstat",
".",
"Start",
"(",
")",
"\n",
"ret",
",",
"_",
",",
"err",
":=",
"unix",
".",
"Syscall",
"(",
"unix",
".",
"SYS_BPF",
",",
"BPF_PROG_GET_NEXT_ID",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"attr",
")",
")",
",",
"unsafe",
".",
"Sizeof",
"(",
"attr",
")",
")",
"\n",
"metricSyscallDuration",
".",
"WithLabelValues",
"(",
"metricOpProgGetNextID",
",",
"metrics",
".",
"Errno2Outcome",
"(",
"err",
")",
")",
".",
"Observe",
"(",
"duration",
".",
"End",
"(",
"err",
"==",
"0",
")",
".",
"Total",
"(",
")",
".",
"Seconds",
"(",
")",
")",
"\n",
"if",
"ret",
"!=",
"0",
"||",
"err",
"!=",
"0",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"attr",
".",
"nextID",
",",
"nil",
"\n",
"}"
] |
// GetProgNextID takes a current program ID and returns the next program ID.
|
[
"GetProgNextID",
"takes",
"a",
"current",
"program",
"ID",
"and",
"returns",
"the",
"next",
"program",
"ID",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/prog_linux.go#L70-L83
|
162,492 |
cilium/cilium
|
pkg/bpf/prog_linux.go
|
GetProgFDByID
|
func GetProgFDByID(id uint32) (int, error) {
attr := attrProg{
progID: uint32(uintptr(id)),
}
fd, _, err := unix.Syscall(unix.SYS_BPF, BPF_PROG_GET_FD_BY_ID, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
if fd < 0 || err != 0 {
return int(fd), fmt.Errorf("Unable to get fd for program id %d: %v", id, err)
}
return int(fd), nil
}
|
go
|
func GetProgFDByID(id uint32) (int, error) {
attr := attrProg{
progID: uint32(uintptr(id)),
}
fd, _, err := unix.Syscall(unix.SYS_BPF, BPF_PROG_GET_FD_BY_ID, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
if fd < 0 || err != 0 {
return int(fd), fmt.Errorf("Unable to get fd for program id %d: %v", id, err)
}
return int(fd), nil
}
|
[
"func",
"GetProgFDByID",
"(",
"id",
"uint32",
")",
"(",
"int",
",",
"error",
")",
"{",
"attr",
":=",
"attrProg",
"{",
"progID",
":",
"uint32",
"(",
"uintptr",
"(",
"id",
")",
")",
",",
"}",
"\n\n",
"fd",
",",
"_",
",",
"err",
":=",
"unix",
".",
"Syscall",
"(",
"unix",
".",
"SYS_BPF",
",",
"BPF_PROG_GET_FD_BY_ID",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"attr",
")",
")",
",",
"unsafe",
".",
"Sizeof",
"(",
"attr",
")",
")",
"\n",
"if",
"fd",
"<",
"0",
"||",
"err",
"!=",
"0",
"{",
"return",
"int",
"(",
"fd",
")",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"int",
"(",
"fd",
")",
",",
"nil",
"\n",
"}"
] |
// GetProgFDByID returns the file descriptor for the program id.
|
[
"GetProgFDByID",
"returns",
"the",
"file",
"descriptor",
"for",
"the",
"program",
"id",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/prog_linux.go#L86-L97
|
162,493 |
cilium/cilium
|
pkg/bpf/prog_linux.go
|
GetProgInfoByFD
|
func GetProgInfoByFD(fd int) (ProgInfo, error) {
info := ProgInfo{}
attrInfo := attrObjInfo{
bpfFD: uint32(fd),
infoLen: uint32(unsafe.Sizeof(info)),
info: uint64(uintptr(unsafe.Pointer(&info))),
}
// This struct must be in sync with union bpf_attr's anonymous struct
attr := struct {
info attrObjInfo
}{
info: attrInfo,
}
duration := spanstat.Start()
ret, _, err := unix.Syscall(unix.SYS_BPF, BPF_OBJ_GET_INFO_BY_FD, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
metricSyscallDuration.WithLabelValues(metricOpObjGetInfoByFD, metrics.Errno2Outcome(err)).Observe(duration.End(err == 0).Total().Seconds())
if ret != 0 || err != 0 {
return ProgInfo{}, fmt.Errorf("Unable to get object info: %v", err)
}
return info, nil
}
|
go
|
func GetProgInfoByFD(fd int) (ProgInfo, error) {
info := ProgInfo{}
attrInfo := attrObjInfo{
bpfFD: uint32(fd),
infoLen: uint32(unsafe.Sizeof(info)),
info: uint64(uintptr(unsafe.Pointer(&info))),
}
// This struct must be in sync with union bpf_attr's anonymous struct
attr := struct {
info attrObjInfo
}{
info: attrInfo,
}
duration := spanstat.Start()
ret, _, err := unix.Syscall(unix.SYS_BPF, BPF_OBJ_GET_INFO_BY_FD, uintptr(unsafe.Pointer(&attr)), unsafe.Sizeof(attr))
metricSyscallDuration.WithLabelValues(metricOpObjGetInfoByFD, metrics.Errno2Outcome(err)).Observe(duration.End(err == 0).Total().Seconds())
if ret != 0 || err != 0 {
return ProgInfo{}, fmt.Errorf("Unable to get object info: %v", err)
}
return info, nil
}
|
[
"func",
"GetProgInfoByFD",
"(",
"fd",
"int",
")",
"(",
"ProgInfo",
",",
"error",
")",
"{",
"info",
":=",
"ProgInfo",
"{",
"}",
"\n",
"attrInfo",
":=",
"attrObjInfo",
"{",
"bpfFD",
":",
"uint32",
"(",
"fd",
")",
",",
"infoLen",
":",
"uint32",
"(",
"unsafe",
".",
"Sizeof",
"(",
"info",
")",
")",
",",
"info",
":",
"uint64",
"(",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"info",
")",
")",
")",
",",
"}",
"\n",
"// This struct must be in sync with union bpf_attr's anonymous struct",
"attr",
":=",
"struct",
"{",
"info",
"attrObjInfo",
"\n",
"}",
"{",
"info",
":",
"attrInfo",
",",
"}",
"\n\n",
"duration",
":=",
"spanstat",
".",
"Start",
"(",
")",
"\n",
"ret",
",",
"_",
",",
"err",
":=",
"unix",
".",
"Syscall",
"(",
"unix",
".",
"SYS_BPF",
",",
"BPF_OBJ_GET_INFO_BY_FD",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"attr",
")",
")",
",",
"unsafe",
".",
"Sizeof",
"(",
"attr",
")",
")",
"\n",
"metricSyscallDuration",
".",
"WithLabelValues",
"(",
"metricOpObjGetInfoByFD",
",",
"metrics",
".",
"Errno2Outcome",
"(",
"err",
")",
")",
".",
"Observe",
"(",
"duration",
".",
"End",
"(",
"err",
"==",
"0",
")",
".",
"Total",
"(",
")",
".",
"Seconds",
"(",
")",
")",
"\n",
"if",
"ret",
"!=",
"0",
"||",
"err",
"!=",
"0",
"{",
"return",
"ProgInfo",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"info",
",",
"nil",
"\n",
"}"
] |
// GetProgInfoByFD gets the bpf program info from its file descriptor.
|
[
"GetProgInfoByFD",
"gets",
"the",
"bpf",
"program",
"info",
"from",
"its",
"file",
"descriptor",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/prog_linux.go#L100-L122
|
162,494 |
cilium/cilium
|
api/v1/server/restapi/endpoint/get_endpoint.go
|
NewGetEndpoint
|
func NewGetEndpoint(ctx *middleware.Context, handler GetEndpointHandler) *GetEndpoint {
return &GetEndpoint{Context: ctx, Handler: handler}
}
|
go
|
func NewGetEndpoint(ctx *middleware.Context, handler GetEndpointHandler) *GetEndpoint {
return &GetEndpoint{Context: ctx, Handler: handler}
}
|
[
"func",
"NewGetEndpoint",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetEndpointHandler",
")",
"*",
"GetEndpoint",
"{",
"return",
"&",
"GetEndpoint",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] |
// NewGetEndpoint creates a new http.Handler for the get endpoint operation
|
[
"NewGetEndpoint",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"endpoint",
"operation"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/endpoint/get_endpoint.go#L28-L30
|
162,495 |
cilium/cilium
|
pkg/cidr/diff.go
|
DiffCIDRLists
|
func DiffCIDRLists(old, new []*CIDR) (add, remove []*CIDR) {
add = listMissingIPNets(createIPNetMap(old), new)
remove = listMissingIPNets(createIPNetMap(new), old)
return
}
|
go
|
func DiffCIDRLists(old, new []*CIDR) (add, remove []*CIDR) {
add = listMissingIPNets(createIPNetMap(old), new)
remove = listMissingIPNets(createIPNetMap(new), old)
return
}
|
[
"func",
"DiffCIDRLists",
"(",
"old",
",",
"new",
"[",
"]",
"*",
"CIDR",
")",
"(",
"add",
",",
"remove",
"[",
"]",
"*",
"CIDR",
")",
"{",
"add",
"=",
"listMissingIPNets",
"(",
"createIPNetMap",
"(",
"old",
")",
",",
"new",
")",
"\n",
"remove",
"=",
"listMissingIPNets",
"(",
"createIPNetMap",
"(",
"new",
")",
",",
"old",
")",
"\n",
"return",
"\n",
"}"
] |
// DiffCIDRLists compares an old and new list of CIDRs and returns the list of
// removed and added CIDRs
|
[
"DiffCIDRLists",
"compares",
"an",
"old",
"and",
"new",
"list",
"of",
"CIDRs",
"and",
"returns",
"the",
"list",
"of",
"removed",
"and",
"added",
"CIDRs"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/cidr/diff.go#L40-L44
|
162,496 |
cilium/cilium
|
pkg/envoy/xds/ack.go
|
NewAckingResourceMutatorWrapper
|
func NewAckingResourceMutatorWrapper(mutator ResourceMutator, nodeToID NodeToIDFunc) *AckingResourceMutatorWrapper {
return &AckingResourceMutatorWrapper{
mutator: mutator,
nodeToID: nodeToID,
pendingCompletions: make(map[*completion.Completion]*pendingCompletion),
}
}
|
go
|
func NewAckingResourceMutatorWrapper(mutator ResourceMutator, nodeToID NodeToIDFunc) *AckingResourceMutatorWrapper {
return &AckingResourceMutatorWrapper{
mutator: mutator,
nodeToID: nodeToID,
pendingCompletions: make(map[*completion.Completion]*pendingCompletion),
}
}
|
[
"func",
"NewAckingResourceMutatorWrapper",
"(",
"mutator",
"ResourceMutator",
",",
"nodeToID",
"NodeToIDFunc",
")",
"*",
"AckingResourceMutatorWrapper",
"{",
"return",
"&",
"AckingResourceMutatorWrapper",
"{",
"mutator",
":",
"mutator",
",",
"nodeToID",
":",
"nodeToID",
",",
"pendingCompletions",
":",
"make",
"(",
"map",
"[",
"*",
"completion",
".",
"Completion",
"]",
"*",
"pendingCompletion",
")",
",",
"}",
"\n",
"}"
] |
// NewAckingResourceMutatorWrapper creates a new AckingResourceMutatorWrapper
// to wrap the given ResourceMutator. The given NodeToIDFunc is used to extract
// a string identifier from an Envoy Node identifier.
|
[
"NewAckingResourceMutatorWrapper",
"creates",
"a",
"new",
"AckingResourceMutatorWrapper",
"to",
"wrap",
"the",
"given",
"ResourceMutator",
".",
"The",
"given",
"NodeToIDFunc",
"is",
"used",
"to",
"extract",
"a",
"string",
"identifier",
"from",
"an",
"Envoy",
"Node",
"identifier",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/ack.go#L118-L124
|
162,497 |
cilium/cilium
|
pkg/envoy/xds/ack.go
|
HandleResourceVersionAck
|
func (m *AckingResourceMutatorWrapper) HandleResourceVersionAck(ackVersion uint64, nackVersion uint64, node *envoy_api_v2_core.Node, resourceNames []string, typeURL string, detail string) {
ackLog := log.WithFields(logrus.Fields{
logfields.XDSVersionInfo: ackVersion,
logfields.XDSNonce: nackVersion,
logfields.XDSClientNode: node,
logfields.XDSTypeURL: typeURL,
})
nodeID, err := m.nodeToID(node)
if err != nil {
// Ignore ACKs from unknown or misconfigured nodes which have invalid
// node identifiers.
ackLog.WithError(err).Warning("invalid ID in Node identifier; ignoring ACK")
return
}
m.locker.Lock()
defer m.locker.Unlock()
remainingCompletions := make(map[*completion.Completion]*pendingCompletion, len(m.pendingCompletions))
for comp, pending := range m.pendingCompletions {
if comp.Err() != nil {
// Completion was canceled or timed out.
// Remove from pending list.
ackLog.Debugf("completion context was canceled: %v", pending)
continue
}
if pending.typeURL == typeURL {
if pending.version <= nackVersion {
// Get the set of resource names we are still waiting for the node
// to ACK.
remainingResourceNames, found := pending.remainingNodesResources[nodeID]
if found {
for _, name := range resourceNames {
delete(remainingResourceNames, name)
}
if len(remainingResourceNames) == 0 {
delete(pending.remainingNodesResources, nodeID)
}
if len(pending.remainingNodesResources) == 0 {
// Completed. Notify and remove from pending list.
if pending.version <= ackVersion {
ackLog.Debugf("completing ACK: %v", pending)
comp.Complete(nil)
} else {
ackLog.Debugf("completing NACK: %v", pending)
comp.Complete(&ProxyError{Err: ErrNackReceived, Detail: detail})
}
continue
}
}
}
}
// Completion didn't match or is still waiting for some ACKs. Keep it
// in the pending list.
remainingCompletions[comp] = pending
}
m.pendingCompletions = remainingCompletions
}
|
go
|
func (m *AckingResourceMutatorWrapper) HandleResourceVersionAck(ackVersion uint64, nackVersion uint64, node *envoy_api_v2_core.Node, resourceNames []string, typeURL string, detail string) {
ackLog := log.WithFields(logrus.Fields{
logfields.XDSVersionInfo: ackVersion,
logfields.XDSNonce: nackVersion,
logfields.XDSClientNode: node,
logfields.XDSTypeURL: typeURL,
})
nodeID, err := m.nodeToID(node)
if err != nil {
// Ignore ACKs from unknown or misconfigured nodes which have invalid
// node identifiers.
ackLog.WithError(err).Warning("invalid ID in Node identifier; ignoring ACK")
return
}
m.locker.Lock()
defer m.locker.Unlock()
remainingCompletions := make(map[*completion.Completion]*pendingCompletion, len(m.pendingCompletions))
for comp, pending := range m.pendingCompletions {
if comp.Err() != nil {
// Completion was canceled or timed out.
// Remove from pending list.
ackLog.Debugf("completion context was canceled: %v", pending)
continue
}
if pending.typeURL == typeURL {
if pending.version <= nackVersion {
// Get the set of resource names we are still waiting for the node
// to ACK.
remainingResourceNames, found := pending.remainingNodesResources[nodeID]
if found {
for _, name := range resourceNames {
delete(remainingResourceNames, name)
}
if len(remainingResourceNames) == 0 {
delete(pending.remainingNodesResources, nodeID)
}
if len(pending.remainingNodesResources) == 0 {
// Completed. Notify and remove from pending list.
if pending.version <= ackVersion {
ackLog.Debugf("completing ACK: %v", pending)
comp.Complete(nil)
} else {
ackLog.Debugf("completing NACK: %v", pending)
comp.Complete(&ProxyError{Err: ErrNackReceived, Detail: detail})
}
continue
}
}
}
}
// Completion didn't match or is still waiting for some ACKs. Keep it
// in the pending list.
remainingCompletions[comp] = pending
}
m.pendingCompletions = remainingCompletions
}
|
[
"func",
"(",
"m",
"*",
"AckingResourceMutatorWrapper",
")",
"HandleResourceVersionAck",
"(",
"ackVersion",
"uint64",
",",
"nackVersion",
"uint64",
",",
"node",
"*",
"envoy_api_v2_core",
".",
"Node",
",",
"resourceNames",
"[",
"]",
"string",
",",
"typeURL",
"string",
",",
"detail",
"string",
")",
"{",
"ackLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"XDSVersionInfo",
":",
"ackVersion",
",",
"logfields",
".",
"XDSNonce",
":",
"nackVersion",
",",
"logfields",
".",
"XDSClientNode",
":",
"node",
",",
"logfields",
".",
"XDSTypeURL",
":",
"typeURL",
",",
"}",
")",
"\n\n",
"nodeID",
",",
"err",
":=",
"m",
".",
"nodeToID",
"(",
"node",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Ignore ACKs from unknown or misconfigured nodes which have invalid",
"// node identifiers.",
"ackLog",
".",
"WithError",
"(",
"err",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"m",
".",
"locker",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"locker",
".",
"Unlock",
"(",
")",
"\n\n",
"remainingCompletions",
":=",
"make",
"(",
"map",
"[",
"*",
"completion",
".",
"Completion",
"]",
"*",
"pendingCompletion",
",",
"len",
"(",
"m",
".",
"pendingCompletions",
")",
")",
"\n\n",
"for",
"comp",
",",
"pending",
":=",
"range",
"m",
".",
"pendingCompletions",
"{",
"if",
"comp",
".",
"Err",
"(",
")",
"!=",
"nil",
"{",
"// Completion was canceled or timed out.",
"// Remove from pending list.",
"ackLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"pending",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"pending",
".",
"typeURL",
"==",
"typeURL",
"{",
"if",
"pending",
".",
"version",
"<=",
"nackVersion",
"{",
"// Get the set of resource names we are still waiting for the node",
"// to ACK.",
"remainingResourceNames",
",",
"found",
":=",
"pending",
".",
"remainingNodesResources",
"[",
"nodeID",
"]",
"\n",
"if",
"found",
"{",
"for",
"_",
",",
"name",
":=",
"range",
"resourceNames",
"{",
"delete",
"(",
"remainingResourceNames",
",",
"name",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"remainingResourceNames",
")",
"==",
"0",
"{",
"delete",
"(",
"pending",
".",
"remainingNodesResources",
",",
"nodeID",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"pending",
".",
"remainingNodesResources",
")",
"==",
"0",
"{",
"// Completed. Notify and remove from pending list.",
"if",
"pending",
".",
"version",
"<=",
"ackVersion",
"{",
"ackLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"pending",
")",
"\n",
"comp",
".",
"Complete",
"(",
"nil",
")",
"\n",
"}",
"else",
"{",
"ackLog",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"pending",
")",
"\n",
"comp",
".",
"Complete",
"(",
"&",
"ProxyError",
"{",
"Err",
":",
"ErrNackReceived",
",",
"Detail",
":",
"detail",
"}",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Completion didn't match or is still waiting for some ACKs. Keep it",
"// in the pending list.",
"remainingCompletions",
"[",
"comp",
"]",
"=",
"pending",
"\n",
"}",
"\n\n",
"m",
".",
"pendingCompletions",
"=",
"remainingCompletions",
"\n",
"}"
] |
// 'ackVersion' is the last version that was acked. 'nackVersion', if greater than 'nackVersion', is the last version that was NACKed.
|
[
"ackVersion",
"is",
"the",
"last",
"version",
"that",
"was",
"acked",
".",
"nackVersion",
"if",
"greater",
"than",
"nackVersion",
"is",
"the",
"last",
"version",
"that",
"was",
"NACKed",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/ack.go#L220-L282
|
162,498 |
cilium/cilium
|
pkg/elf/symbols.go
|
sort
|
func (c symbolSlice) sort() symbolSlice {
sort.Slice(c, func(i, j int) bool { return c[i].offset < c[j].offset })
return c
}
|
go
|
func (c symbolSlice) sort() symbolSlice {
sort.Slice(c, func(i, j int) bool { return c[i].offset < c[j].offset })
return c
}
|
[
"func",
"(",
"c",
"symbolSlice",
")",
"sort",
"(",
")",
"symbolSlice",
"{",
"sort",
".",
"Slice",
"(",
"c",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"c",
"[",
"i",
"]",
".",
"offset",
"<",
"c",
"[",
"j",
"]",
".",
"offset",
"}",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// sort a slice of symbols by offset.
|
[
"sort",
"a",
"slice",
"of",
"symbols",
"by",
"offset",
"."
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/elf/symbols.go#L92-L95
|
162,499 |
cilium/cilium
|
pkg/api/apipanic.go
|
ServeHTTP
|
func (h *APIPanicHandler) ServeHTTP(wr http.ResponseWriter, req *http.Request) {
defer func() {
if r := recover(); r != nil {
fields := logrus.Fields{
"panic_message": r,
"url": req.URL.String(),
"method": req.Method,
"client": req.RemoteAddr,
}
log.WithFields(fields).Warn("Cilium API handler panicked")
if logging.DefaultLogger.IsLevelEnabled(logrus.DebugLevel) {
os.Stdout.Write(debug.Stack())
}
wr.WriteHeader(http.StatusInternalServerError)
if _, err := wr.Write([]byte("Internal error occurred, check Cilium logs for details.")); err != nil {
log.WithError(err).Debug("Failed to write API response")
}
}
}()
h.Next.ServeHTTP(wr, req)
}
|
go
|
func (h *APIPanicHandler) ServeHTTP(wr http.ResponseWriter, req *http.Request) {
defer func() {
if r := recover(); r != nil {
fields := logrus.Fields{
"panic_message": r,
"url": req.URL.String(),
"method": req.Method,
"client": req.RemoteAddr,
}
log.WithFields(fields).Warn("Cilium API handler panicked")
if logging.DefaultLogger.IsLevelEnabled(logrus.DebugLevel) {
os.Stdout.Write(debug.Stack())
}
wr.WriteHeader(http.StatusInternalServerError)
if _, err := wr.Write([]byte("Internal error occurred, check Cilium logs for details.")); err != nil {
log.WithError(err).Debug("Failed to write API response")
}
}
}()
h.Next.ServeHTTP(wr, req)
}
|
[
"func",
"(",
"h",
"*",
"APIPanicHandler",
")",
"ServeHTTP",
"(",
"wr",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"fields",
":=",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"r",
",",
"\"",
"\"",
":",
"req",
".",
"URL",
".",
"String",
"(",
")",
",",
"\"",
"\"",
":",
"req",
".",
"Method",
",",
"\"",
"\"",
":",
"req",
".",
"RemoteAddr",
",",
"}",
"\n",
"log",
".",
"WithFields",
"(",
"fields",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"if",
"logging",
".",
"DefaultLogger",
".",
"IsLevelEnabled",
"(",
"logrus",
".",
"DebugLevel",
")",
"{",
"os",
".",
"Stdout",
".",
"Write",
"(",
"debug",
".",
"Stack",
"(",
")",
")",
"\n",
"}",
"\n",
"wr",
".",
"WriteHeader",
"(",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"wr",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"h",
".",
"Next",
".",
"ServeHTTP",
"(",
"wr",
",",
"req",
")",
"\n",
"}"
] |
// ServeHTTP implements the http.Handler interface.
// It recovers from panics of all next handlers and logs them
|
[
"ServeHTTP",
"implements",
"the",
"http",
".",
"Handler",
"interface",
".",
"It",
"recovers",
"from",
"panics",
"of",
"all",
"next",
"handlers",
"and",
"logs",
"them"
] |
6ecfff82c2314dd9d847645361b57e2646eed64b
|
https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/api/apipanic.go#L34-L54
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.