id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
162,300 | cilium/cilium | pkg/pprof/pprof.go | Enable | func Enable() {
go func() {
if err := http.ListenAndServe(apiAddress, nil); err != nil {
log.WithError(err).Warn("Unable to serve pprof API")
}
}()
} | go | func Enable() {
go func() {
if err := http.ListenAndServe(apiAddress, nil); err != nil {
log.WithError(err).Warn("Unable to serve pprof API")
}
}()
} | [
"func",
"Enable",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"http",
".",
"ListenAndServe",
"(",
"apiAddress",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // Enable runs an HTTP server to serve the pprof API | [
"Enable",
"runs",
"an",
"HTTP",
"server",
"to",
"serve",
"the",
"pprof",
"API"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/pprof/pprof.go#L31-L37 |
162,301 | cilium/cilium | proxylib/memcached/binary/parser.go | Create | func (p *ParserFactory) Create(connection *proxylib.Connection) proxylib.Parser {
log.Infof("ParserFactory: Create: %v", connection)
return &Parser{connection: connection, injectQueue: make([]queuedInject, 0)}
} | go | func (p *ParserFactory) Create(connection *proxylib.Connection) proxylib.Parser {
log.Infof("ParserFactory: Create: %v", connection)
return &Parser{connection: connection, injectQueue: make([]queuedInject, 0)}
} | [
"func",
"(",
"p",
"*",
"ParserFactory",
")",
"Create",
"(",
"connection",
"*",
"proxylib",
".",
"Connection",
")",
"proxylib",
".",
"Parser",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"connection",
")",
"\n",
"return",
"&",
"Parser",
"{",
"connection",
":",
"connection",
",",
"injectQueue",
":",
"make",
"(",
"[",
"]",
"queuedInject",
",",
"0",
")",
"}",
"\n",
"}"
] | // Create creates binary memcached parser | [
"Create",
"creates",
"binary",
"memcached",
"parser"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/memcached/binary/parser.go#L33-L36 |
162,302 | cilium/cilium | api/v1/health/models/health_response.go | Validate | func (m *HealthResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCilium(formats); err != nil {
res = append(res, err)
}
if err := m.validateSystemLoad(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *HealthResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCilium(formats); err != nil {
res = append(res, err)
}
if err := m.validateSystemLoad(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"HealthResponse",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCilium",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateSystemLoad",
"(",
"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 response | [
"Validate",
"validates",
"this",
"health",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/health_response.go#L34-L49 |
162,303 | cilium/cilium | pkg/workloads/docker.go | networksMock | func networksMock() func(req *http.Request) (*http.Response, error) {
return func(req *http.Request) (*http.Response, error) {
if !strings.HasPrefix(req.URL.Path, "/v1.21/networks") {
return nil, fmt.Errorf("Only expecting /v1.21/networks requests, got %s", req.URL.Path)
}
header := http.Header{}
header.Set("Content-Type", "application/json")
body, err := json.Marshal(&dTypes.NetworkResource{
Name: "12345",
ID: "1234",
Scope: "global",
Driver: "cilium-net",
EnableIPv6: true,
IPAM: dNetwork.IPAM{},
Internal: false,
// this map contains all endpoints except 259
Containers: map[string]dTypes.EndpointResource{
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100256": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800200256",
},
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100257": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800200257",
},
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100258": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800100258",
},
},
Options: map[string]string{},
Labels: map[string]string{},
})
if err != nil {
return nil, err
}
return &http.Response{
StatusCode: 200,
Body: ioutil.NopCloser(bytes.NewReader(body)),
Header: header,
}, nil
}
} | go | func networksMock() func(req *http.Request) (*http.Response, error) {
return func(req *http.Request) (*http.Response, error) {
if !strings.HasPrefix(req.URL.Path, "/v1.21/networks") {
return nil, fmt.Errorf("Only expecting /v1.21/networks requests, got %s", req.URL.Path)
}
header := http.Header{}
header.Set("Content-Type", "application/json")
body, err := json.Marshal(&dTypes.NetworkResource{
Name: "12345",
ID: "1234",
Scope: "global",
Driver: "cilium-net",
EnableIPv6: true,
IPAM: dNetwork.IPAM{},
Internal: false,
// this map contains all endpoints except 259
Containers: map[string]dTypes.EndpointResource{
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100256": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800200256",
},
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100257": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800200257",
},
"603e047d2268a57f5a5f93f7f9e1263e9207e348a06654bf64948def00100258": {
EndpointID: "93529fda8c401a071d21d6bd46fdf5499b9014dcb5a35f2e3efaa8d800100258",
},
},
Options: map[string]string{},
Labels: map[string]string{},
})
if err != nil {
return nil, err
}
return &http.Response{
StatusCode: 200,
Body: ioutil.NopCloser(bytes.NewReader(body)),
Header: header,
}, nil
}
} | [
"func",
"networksMock",
"(",
")",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"req",
".",
"URL",
".",
"Path",
",",
"\"",
"\"",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"req",
".",
"URL",
".",
"Path",
")",
"\n",
"}",
"\n\n",
"header",
":=",
"http",
".",
"Header",
"{",
"}",
"\n",
"header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"dTypes",
".",
"NetworkResource",
"{",
"Name",
":",
"\"",
"\"",
",",
"ID",
":",
"\"",
"\"",
",",
"Scope",
":",
"\"",
"\"",
",",
"Driver",
":",
"\"",
"\"",
",",
"EnableIPv6",
":",
"true",
",",
"IPAM",
":",
"dNetwork",
".",
"IPAM",
"{",
"}",
",",
"Internal",
":",
"false",
",",
"// this map contains all endpoints except 259",
"Containers",
":",
"map",
"[",
"string",
"]",
"dTypes",
".",
"EndpointResource",
"{",
"\"",
"\"",
":",
"{",
"EndpointID",
":",
"\"",
"\"",
",",
"}",
",",
"\"",
"\"",
":",
"{",
"EndpointID",
":",
"\"",
"\"",
",",
"}",
",",
"\"",
"\"",
":",
"{",
"EndpointID",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"Options",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"Labels",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"http",
".",
"Response",
"{",
"StatusCode",
":",
"200",
",",
"Body",
":",
"ioutil",
".",
"NopCloser",
"(",
"bytes",
".",
"NewReader",
"(",
"body",
")",
")",
",",
"Header",
":",
"header",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Helper function to mock docker calls to networks endpoint | [
"Helper",
"function",
"to",
"mock",
"docker",
"calls",
"to",
"networks",
"endpoint"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/workloads/docker.go#L159-L201 |
162,304 | cilium/cilium | pkg/workloads/docker.go | GetAllInfraContainersPID | func (d *dockerClient) GetAllInfraContainersPID() (map[string]int, error) {
timeoutCtx, cancel := ctx.WithTimeout(ctx.Background(), 10*time.Second)
defer cancel()
cList, err := Client().workloadIDsList(timeoutCtx)
if err != nil {
log.WithError(err).Error("Failed to retrieve the container list")
return nil, err
}
pids := map[string]int{}
for _, contID := range cList {
cJSON, err := d.ContainerInspect(context.Background(), contID)
if err != nil {
continue
}
if cJSON.Config == nil || !utils.IsInfraContainer(cJSON.Config.Labels) {
continue
}
if cJSON.State == nil || !cJSON.State.Running {
continue
}
pids[cJSON.ID] = cJSON.State.Pid
}
return pids, nil
} | go | func (d *dockerClient) GetAllInfraContainersPID() (map[string]int, error) {
timeoutCtx, cancel := ctx.WithTimeout(ctx.Background(), 10*time.Second)
defer cancel()
cList, err := Client().workloadIDsList(timeoutCtx)
if err != nil {
log.WithError(err).Error("Failed to retrieve the container list")
return nil, err
}
pids := map[string]int{}
for _, contID := range cList {
cJSON, err := d.ContainerInspect(context.Background(), contID)
if err != nil {
continue
}
if cJSON.Config == nil || !utils.IsInfraContainer(cJSON.Config.Labels) {
continue
}
if cJSON.State == nil || !cJSON.State.Running {
continue
}
pids[cJSON.ID] = cJSON.State.Pid
}
return pids, nil
} | [
"func",
"(",
"d",
"*",
"dockerClient",
")",
"GetAllInfraContainersPID",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"error",
")",
"{",
"timeoutCtx",
",",
"cancel",
":=",
"ctx",
".",
"WithTimeout",
"(",
"ctx",
".",
"Background",
"(",
")",
",",
"10",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"cList",
",",
"err",
":=",
"Client",
"(",
")",
".",
"workloadIDsList",
"(",
"timeoutCtx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pids",
":=",
"map",
"[",
"string",
"]",
"int",
"{",
"}",
"\n",
"for",
"_",
",",
"contID",
":=",
"range",
"cList",
"{",
"cJSON",
",",
"err",
":=",
"d",
".",
"ContainerInspect",
"(",
"context",
".",
"Background",
"(",
")",
",",
"contID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"cJSON",
".",
"Config",
"==",
"nil",
"||",
"!",
"utils",
".",
"IsInfraContainer",
"(",
"cJSON",
".",
"Config",
".",
"Labels",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"cJSON",
".",
"State",
"==",
"nil",
"||",
"!",
"cJSON",
".",
"State",
".",
"Running",
"{",
"continue",
"\n",
"}",
"\n",
"pids",
"[",
"cJSON",
".",
"ID",
"]",
"=",
"cJSON",
".",
"State",
".",
"Pid",
"\n",
"}",
"\n\n",
"return",
"pids",
",",
"nil",
"\n",
"}"
] | // GetAllInfraContainersPID returns a map that maps container IDs to the PID
// of that container. | [
"GetAllInfraContainersPID",
"returns",
"a",
"map",
"that",
"maps",
"container",
"IDs",
"to",
"the",
"PID",
"of",
"that",
"container",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/workloads/docker.go#L544-L569 |
162,305 | cilium/cilium | pkg/bpf/map.go | mapTypeToFeatureString | func mapTypeToFeatureString(mt MapType) string {
var featureString string
switch mt {
case MapTypeLPMTrie:
featureString = fmt.Sprintf("#define HAVE_LPM_MAP_TYPE")
case MapTypeLRUHash:
featureString = fmt.Sprintf("#define HAVE_LRU_MAP_TYPE")
default:
break
}
return featureString
} | go | func mapTypeToFeatureString(mt MapType) string {
var featureString string
switch mt {
case MapTypeLPMTrie:
featureString = fmt.Sprintf("#define HAVE_LPM_MAP_TYPE")
case MapTypeLRUHash:
featureString = fmt.Sprintf("#define HAVE_LRU_MAP_TYPE")
default:
break
}
return featureString
} | [
"func",
"mapTypeToFeatureString",
"(",
"mt",
"MapType",
")",
"string",
"{",
"var",
"featureString",
"string",
"\n",
"switch",
"mt",
"{",
"case",
"MapTypeLPMTrie",
":",
"featureString",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"MapTypeLRUHash",
":",
"featureString",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"break",
"\n",
"}",
"\n",
"return",
"featureString",
"\n",
"}"
] | // mapTypeToFeatureString maps a MapType into a string defined by run_probes.sh | [
"mapTypeToFeatureString",
"maps",
"a",
"MapType",
"into",
"a",
"string",
"defined",
"by",
"run_probes",
".",
"sh"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/map.go#L166-L177 |
162,306 | cilium/cilium | pkg/workloads/defaults.go | EndpointCorrelationSleepTime | func EndpointCorrelationSleepTime(try int) time.Duration {
return time.Duration(try) * time.Second
} | go | func EndpointCorrelationSleepTime(try int) time.Duration {
return time.Duration(try) * time.Second
} | [
"func",
"EndpointCorrelationSleepTime",
"(",
"try",
"int",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Duration",
"(",
"try",
")",
"*",
"time",
".",
"Second",
"\n",
"}"
] | // EndpointCorrelationSleepTime returns the sleep time between correlation
// attempts | [
"EndpointCorrelationSleepTime",
"returns",
"the",
"sleep",
"time",
"between",
"correlation",
"attempts"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/workloads/defaults.go#L37-L39 |
162,307 | cilium/cilium | proxylib/memcached/text/parser.go | injectFromQueue | func (p *Parser) injectFromQueue() int {
injected := 0
for _, rep := range p.replyQueue {
if rep.denied {
injected++
p.injectDeniedMessage()
} else {
break
}
}
if injected > 0 {
p.replyQueue = p.replyQueue[injected:]
}
return injected * len(DeniedMsg)
} | go | func (p *Parser) injectFromQueue() int {
injected := 0
for _, rep := range p.replyQueue {
if rep.denied {
injected++
p.injectDeniedMessage()
} else {
break
}
}
if injected > 0 {
p.replyQueue = p.replyQueue[injected:]
}
return injected * len(DeniedMsg)
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"injectFromQueue",
"(",
")",
"int",
"{",
"injected",
":=",
"0",
"\n",
"for",
"_",
",",
"rep",
":=",
"range",
"p",
".",
"replyQueue",
"{",
"if",
"rep",
".",
"denied",
"{",
"injected",
"++",
"\n",
"p",
".",
"injectDeniedMessage",
"(",
")",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n\n",
"}",
"\n",
"if",
"injected",
">",
"0",
"{",
"p",
".",
"replyQueue",
"=",
"p",
".",
"replyQueue",
"[",
"injected",
":",
"]",
"\n",
"}",
"\n",
"return",
"injected",
"*",
"len",
"(",
"DeniedMsg",
")",
"\n",
"}"
] | // returns injected bytes | [
"returns",
"injected",
"bytes"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/memcached/text/parser.go#L305-L320 |
162,308 | cilium/cilium | pkg/datapath/fake/node_addressing.go | NewIPv4OnlyNodeAddressing | func NewIPv4OnlyNodeAddressing() datapath.NodeAddressing {
return &fakeNodeAddressing{
ipv4: addressFamily{
router: net.ParseIP("1.1.1.2"),
primaryExternal: net.ParseIP("1.1.1.1"),
allocCIDR: cidr.MustParseCIDR("1.1.1.0/24"),
},
ipv6: addressFamily{},
}
} | go | func NewIPv4OnlyNodeAddressing() datapath.NodeAddressing {
return &fakeNodeAddressing{
ipv4: addressFamily{
router: net.ParseIP("1.1.1.2"),
primaryExternal: net.ParseIP("1.1.1.1"),
allocCIDR: cidr.MustParseCIDR("1.1.1.0/24"),
},
ipv6: addressFamily{},
}
} | [
"func",
"NewIPv4OnlyNodeAddressing",
"(",
")",
"datapath",
".",
"NodeAddressing",
"{",
"return",
"&",
"fakeNodeAddressing",
"{",
"ipv4",
":",
"addressFamily",
"{",
"router",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"primaryExternal",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"allocCIDR",
":",
"cidr",
".",
"MustParseCIDR",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"ipv6",
":",
"addressFamily",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewIPv4OnlyNodeAddressing returns a new fake node addressing where IPv6 is
// disabled | [
"NewIPv4OnlyNodeAddressing",
"returns",
"a",
"new",
"fake",
"node",
"addressing",
"where",
"IPv6",
"is",
"disabled"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/fake/node_addressing.go#L44-L53 |
162,309 | cilium/cilium | pkg/datapath/fake/node_addressing.go | NewNodeAddressing | func NewNodeAddressing() datapath.NodeAddressing {
return &fakeNodeAddressing{
ipv4: addressFamily{
router: net.ParseIP("1.1.1.2"),
primaryExternal: net.ParseIP("1.1.1.1"),
allocCIDR: cidr.MustParseCIDR("1.1.1.0/24"),
},
ipv6: addressFamily{
router: net.ParseIP("cafe::2"),
primaryExternal: net.ParseIP("cafe::1"),
allocCIDR: cidr.MustParseCIDR("cafe::/96"),
},
}
} | go | func NewNodeAddressing() datapath.NodeAddressing {
return &fakeNodeAddressing{
ipv4: addressFamily{
router: net.ParseIP("1.1.1.2"),
primaryExternal: net.ParseIP("1.1.1.1"),
allocCIDR: cidr.MustParseCIDR("1.1.1.0/24"),
},
ipv6: addressFamily{
router: net.ParseIP("cafe::2"),
primaryExternal: net.ParseIP("cafe::1"),
allocCIDR: cidr.MustParseCIDR("cafe::/96"),
},
}
} | [
"func",
"NewNodeAddressing",
"(",
")",
"datapath",
".",
"NodeAddressing",
"{",
"return",
"&",
"fakeNodeAddressing",
"{",
"ipv4",
":",
"addressFamily",
"{",
"router",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"primaryExternal",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"allocCIDR",
":",
"cidr",
".",
"MustParseCIDR",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"ipv6",
":",
"addressFamily",
"{",
"router",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"primaryExternal",
":",
"net",
".",
"ParseIP",
"(",
"\"",
"\"",
")",
",",
"allocCIDR",
":",
"cidr",
".",
"MustParseCIDR",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewNodeAddressing returns a new fake node addressing | [
"NewNodeAddressing",
"returns",
"a",
"new",
"fake",
"node",
"addressing"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/fake/node_addressing.go#L56-L69 |
162,310 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_labels_parameters.go | WithTimeout | func (o *GetEndpointIDLabelsParams) WithTimeout(timeout time.Duration) *GetEndpointIDLabelsParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetEndpointIDLabelsParams) WithTimeout(timeout time.Duration) *GetEndpointIDLabelsParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDLabelsParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetEndpointIDLabelsParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get endpoint ID labels params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"endpoint",
"ID",
"labels",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_labels_parameters.go#L88-L91 |
162,311 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_labels_parameters.go | WithContext | func (o *GetEndpointIDLabelsParams) WithContext(ctx context.Context) *GetEndpointIDLabelsParams {
o.SetContext(ctx)
return o
} | go | func (o *GetEndpointIDLabelsParams) WithContext(ctx context.Context) *GetEndpointIDLabelsParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDLabelsParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetEndpointIDLabelsParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get endpoint ID labels params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"endpoint",
"ID",
"labels",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_labels_parameters.go#L99-L102 |
162,312 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_labels_parameters.go | WithHTTPClient | func (o *GetEndpointIDLabelsParams) WithHTTPClient(client *http.Client) *GetEndpointIDLabelsParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetEndpointIDLabelsParams) WithHTTPClient(client *http.Client) *GetEndpointIDLabelsParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDLabelsParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetEndpointIDLabelsParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get endpoint ID labels params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"endpoint",
"ID",
"labels",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_labels_parameters.go#L110-L113 |
162,313 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_labels_parameters.go | WithID | func (o *GetEndpointIDLabelsParams) WithID(id string) *GetEndpointIDLabelsParams {
o.SetID(id)
return o
} | go | func (o *GetEndpointIDLabelsParams) WithID(id string) *GetEndpointIDLabelsParams {
o.SetID(id)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDLabelsParams",
")",
"WithID",
"(",
"id",
"string",
")",
"*",
"GetEndpointIDLabelsParams",
"{",
"o",
".",
"SetID",
"(",
"id",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithID adds the id to the get endpoint ID labels params | [
"WithID",
"adds",
"the",
"id",
"to",
"the",
"get",
"endpoint",
"ID",
"labels",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_labels_parameters.go#L121-L124 |
162,314 | cilium/cilium | api/v1/server/restapi/service/get_service_responses.go | WithPayload | func (o *GetServiceOK) WithPayload(payload []*models.Service) *GetServiceOK {
o.Payload = payload
return o
} | go | func (o *GetServiceOK) WithPayload(payload []*models.Service) *GetServiceOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetServiceOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"Service",
")",
"*",
"GetServiceOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get service o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"service",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/service/get_service_responses.go#L38-L41 |
162,315 | cilium/cilium | pkg/uuid/uuid.go | NewUUID | func NewUUID() uuid.UUID {
uuidLock.Lock()
defer uuidLock.Unlock()
result := uuid.NewUUID()
// The UUID package is naive and can generate identical UUIDs if the
// time interval is quick enough.
// The UUID uses 100 ns increments so it's short enough to actively
// wait for a new value.
for uuid.Equal(lastUUID, result) == true {
result = uuid.NewUUID()
}
lastUUID = result
return result
} | go | func NewUUID() uuid.UUID {
uuidLock.Lock()
defer uuidLock.Unlock()
result := uuid.NewUUID()
// The UUID package is naive and can generate identical UUIDs if the
// time interval is quick enough.
// The UUID uses 100 ns increments so it's short enough to actively
// wait for a new value.
for uuid.Equal(lastUUID, result) == true {
result = uuid.NewUUID()
}
lastUUID = result
return result
} | [
"func",
"NewUUID",
"(",
")",
"uuid",
".",
"UUID",
"{",
"uuidLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"uuidLock",
".",
"Unlock",
"(",
")",
"\n",
"result",
":=",
"uuid",
".",
"NewUUID",
"(",
")",
"\n",
"// The UUID package is naive and can generate identical UUIDs if the",
"// time interval is quick enough.",
"// The UUID uses 100 ns increments so it's short enough to actively",
"// wait for a new value.",
"for",
"uuid",
".",
"Equal",
"(",
"lastUUID",
",",
"result",
")",
"==",
"true",
"{",
"result",
"=",
"uuid",
".",
"NewUUID",
"(",
")",
"\n",
"}",
"\n",
"lastUUID",
"=",
"result",
"\n",
"return",
"result",
"\n",
"}"
] | // NewUUID returns a new UUID | [
"NewUUID",
"returns",
"a",
"new",
"UUID"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/uuid/uuid.go#L29-L42 |
162,316 | cilium/cilium | api/v1/client/endpoint/patch_endpoint_id_config_parameters.go | WithTimeout | func (o *PatchEndpointIDConfigParams) WithTimeout(timeout time.Duration) *PatchEndpointIDConfigParams {
o.SetTimeout(timeout)
return o
} | go | func (o *PatchEndpointIDConfigParams) WithTimeout(timeout time.Duration) *PatchEndpointIDConfigParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"PatchEndpointIDConfigParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"PatchEndpointIDConfigParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the patch endpoint ID config params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"patch",
"endpoint",
"ID",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/patch_endpoint_id_config_parameters.go#L92-L95 |
162,317 | cilium/cilium | api/v1/client/endpoint/patch_endpoint_id_config_parameters.go | WithContext | func (o *PatchEndpointIDConfigParams) WithContext(ctx context.Context) *PatchEndpointIDConfigParams {
o.SetContext(ctx)
return o
} | go | func (o *PatchEndpointIDConfigParams) WithContext(ctx context.Context) *PatchEndpointIDConfigParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"PatchEndpointIDConfigParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"PatchEndpointIDConfigParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the patch endpoint ID config params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"patch",
"endpoint",
"ID",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/patch_endpoint_id_config_parameters.go#L103-L106 |
162,318 | cilium/cilium | api/v1/client/endpoint/patch_endpoint_id_config_parameters.go | WithHTTPClient | func (o *PatchEndpointIDConfigParams) WithHTTPClient(client *http.Client) *PatchEndpointIDConfigParams {
o.SetHTTPClient(client)
return o
} | go | func (o *PatchEndpointIDConfigParams) WithHTTPClient(client *http.Client) *PatchEndpointIDConfigParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"PatchEndpointIDConfigParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"PatchEndpointIDConfigParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the patch endpoint ID config params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"patch",
"endpoint",
"ID",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/patch_endpoint_id_config_parameters.go#L114-L117 |
162,319 | cilium/cilium | api/v1/client/endpoint/patch_endpoint_id_config_parameters.go | WithEndpointConfiguration | func (o *PatchEndpointIDConfigParams) WithEndpointConfiguration(endpointConfiguration *models.EndpointConfigurationSpec) *PatchEndpointIDConfigParams {
o.SetEndpointConfiguration(endpointConfiguration)
return o
} | go | func (o *PatchEndpointIDConfigParams) WithEndpointConfiguration(endpointConfiguration *models.EndpointConfigurationSpec) *PatchEndpointIDConfigParams {
o.SetEndpointConfiguration(endpointConfiguration)
return o
} | [
"func",
"(",
"o",
"*",
"PatchEndpointIDConfigParams",
")",
"WithEndpointConfiguration",
"(",
"endpointConfiguration",
"*",
"models",
".",
"EndpointConfigurationSpec",
")",
"*",
"PatchEndpointIDConfigParams",
"{",
"o",
".",
"SetEndpointConfiguration",
"(",
"endpointConfiguration",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithEndpointConfiguration adds the endpointConfiguration to the patch endpoint ID config params | [
"WithEndpointConfiguration",
"adds",
"the",
"endpointConfiguration",
"to",
"the",
"patch",
"endpoint",
"ID",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/patch_endpoint_id_config_parameters.go#L125-L128 |
162,320 | cilium/cilium | api/v1/client/endpoint/patch_endpoint_id_config_parameters.go | WithID | func (o *PatchEndpointIDConfigParams) WithID(id string) *PatchEndpointIDConfigParams {
o.SetID(id)
return o
} | go | func (o *PatchEndpointIDConfigParams) WithID(id string) *PatchEndpointIDConfigParams {
o.SetID(id)
return o
} | [
"func",
"(",
"o",
"*",
"PatchEndpointIDConfigParams",
")",
"WithID",
"(",
"id",
"string",
")",
"*",
"PatchEndpointIDConfigParams",
"{",
"o",
".",
"SetID",
"(",
"id",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithID adds the id to the patch endpoint ID config params | [
"WithID",
"adds",
"the",
"id",
"to",
"the",
"patch",
"endpoint",
"ID",
"config",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/patch_endpoint_id_config_parameters.go#L136-L139 |
162,321 | cilium/cilium | pkg/k8s/client.go | createConfig | func createConfig(endpoint, kubeCfgPath string) (*rest.Config, error) {
userAgent := fmt.Sprintf("Cilium %s", version.Version)
// If the endpoint and the kubeCfgPath are empty then we can try getting
// the rest.Config from the InClusterConfig
if endpoint == "" && kubeCfgPath == "" {
config, err := rest.InClusterConfig()
if err != nil {
return nil, err
}
config.UserAgent = userAgent
return config, nil
}
if kubeCfgPath != "" {
config, err := clientcmd.BuildConfigFromFlags("", kubeCfgPath)
if err != nil {
return nil, err
}
config.UserAgent = userAgent
return config, nil
}
config := &rest.Config{Host: endpoint, UserAgent: userAgent}
err := rest.SetKubernetesDefaults(config)
return config, err
} | go | func createConfig(endpoint, kubeCfgPath string) (*rest.Config, error) {
userAgent := fmt.Sprintf("Cilium %s", version.Version)
// If the endpoint and the kubeCfgPath are empty then we can try getting
// the rest.Config from the InClusterConfig
if endpoint == "" && kubeCfgPath == "" {
config, err := rest.InClusterConfig()
if err != nil {
return nil, err
}
config.UserAgent = userAgent
return config, nil
}
if kubeCfgPath != "" {
config, err := clientcmd.BuildConfigFromFlags("", kubeCfgPath)
if err != nil {
return nil, err
}
config.UserAgent = userAgent
return config, nil
}
config := &rest.Config{Host: endpoint, UserAgent: userAgent}
err := rest.SetKubernetesDefaults(config)
return config, err
} | [
"func",
"createConfig",
"(",
"endpoint",
",",
"kubeCfgPath",
"string",
")",
"(",
"*",
"rest",
".",
"Config",
",",
"error",
")",
"{",
"userAgent",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"version",
".",
"Version",
")",
"\n\n",
"// If the endpoint and the kubeCfgPath are empty then we can try getting",
"// the rest.Config from the InClusterConfig",
"if",
"endpoint",
"==",
"\"",
"\"",
"&&",
"kubeCfgPath",
"==",
"\"",
"\"",
"{",
"config",
",",
"err",
":=",
"rest",
".",
"InClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"config",
".",
"UserAgent",
"=",
"userAgent",
"\n",
"return",
"config",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"kubeCfgPath",
"!=",
"\"",
"\"",
"{",
"config",
",",
"err",
":=",
"clientcmd",
".",
"BuildConfigFromFlags",
"(",
"\"",
"\"",
",",
"kubeCfgPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"config",
".",
"UserAgent",
"=",
"userAgent",
"\n",
"return",
"config",
",",
"nil",
"\n",
"}",
"\n\n",
"config",
":=",
"&",
"rest",
".",
"Config",
"{",
"Host",
":",
"endpoint",
",",
"UserAgent",
":",
"userAgent",
"}",
"\n",
"err",
":=",
"rest",
".",
"SetKubernetesDefaults",
"(",
"config",
")",
"\n\n",
"return",
"config",
",",
"err",
"\n",
"}"
] | // CreateConfig creates a rest.Config for a given endpoint using a kubeconfig file. | [
"CreateConfig",
"creates",
"a",
"rest",
".",
"Config",
"for",
"a",
"given",
"endpoint",
"using",
"a",
"kubeconfig",
"file",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client.go#L47-L74 |
162,322 | cilium/cilium | pkg/k8s/client.go | CreateConfigFromAgentResponse | func CreateConfigFromAgentResponse(resp *models.DaemonConfiguration) (*rest.Config, error) {
return createConfig(resp.Status.K8sEndpoint, resp.Status.K8sConfiguration)
} | go | func CreateConfigFromAgentResponse(resp *models.DaemonConfiguration) (*rest.Config, error) {
return createConfig(resp.Status.K8sEndpoint, resp.Status.K8sConfiguration)
} | [
"func",
"CreateConfigFromAgentResponse",
"(",
"resp",
"*",
"models",
".",
"DaemonConfiguration",
")",
"(",
"*",
"rest",
".",
"Config",
",",
"error",
")",
"{",
"return",
"createConfig",
"(",
"resp",
".",
"Status",
".",
"K8sEndpoint",
",",
"resp",
".",
"Status",
".",
"K8sConfiguration",
")",
"\n",
"}"
] | // CreateConfigFromAgentResponse creates a client configuration from a
// models.DaemonConfigurationResponse | [
"CreateConfigFromAgentResponse",
"creates",
"a",
"client",
"configuration",
"from",
"a",
"models",
".",
"DaemonConfigurationResponse"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client.go#L78-L80 |
162,323 | cilium/cilium | pkg/k8s/client.go | CreateClient | func CreateClient(config *rest.Config) (*kubernetes.Clientset, error) {
cs, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
stop := make(chan struct{})
timeout := time.NewTimer(time.Minute)
defer timeout.Stop()
wait.Until(func() {
// FIXME: Use config.String() when we rebase to latest go-client
log.WithField("host", config.Host).Info("Establishing connection to apiserver")
err = isConnReady(cs)
if err == nil {
close(stop)
return
}
select {
case <-timeout.C:
log.WithError(err).WithField(logfields.IPAddr, config.Host).Error("Unable to contact k8s api-server")
close(stop)
default:
}
}, 5*time.Second, stop)
if err == nil {
log.Info("Connected to apiserver")
}
return cs, err
} | go | func CreateClient(config *rest.Config) (*kubernetes.Clientset, error) {
cs, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
stop := make(chan struct{})
timeout := time.NewTimer(time.Minute)
defer timeout.Stop()
wait.Until(func() {
// FIXME: Use config.String() when we rebase to latest go-client
log.WithField("host", config.Host).Info("Establishing connection to apiserver")
err = isConnReady(cs)
if err == nil {
close(stop)
return
}
select {
case <-timeout.C:
log.WithError(err).WithField(logfields.IPAddr, config.Host).Error("Unable to contact k8s api-server")
close(stop)
default:
}
}, 5*time.Second, stop)
if err == nil {
log.Info("Connected to apiserver")
}
return cs, err
} | [
"func",
"CreateClient",
"(",
"config",
"*",
"rest",
".",
"Config",
")",
"(",
"*",
"kubernetes",
".",
"Clientset",
",",
"error",
")",
"{",
"cs",
",",
"err",
":=",
"kubernetes",
".",
"NewForConfig",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stop",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"timeout",
":=",
"time",
".",
"NewTimer",
"(",
"time",
".",
"Minute",
")",
"\n",
"defer",
"timeout",
".",
"Stop",
"(",
")",
"\n",
"wait",
".",
"Until",
"(",
"func",
"(",
")",
"{",
"// FIXME: Use config.String() when we rebase to latest go-client",
"log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"config",
".",
"Host",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"err",
"=",
"isConnReady",
"(",
"cs",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"close",
"(",
"stop",
")",
"\n",
"return",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"timeout",
".",
"C",
":",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"WithField",
"(",
"logfields",
".",
"IPAddr",
",",
"config",
".",
"Host",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"close",
"(",
"stop",
")",
"\n",
"default",
":",
"}",
"\n",
"}",
",",
"5",
"*",
"time",
".",
"Second",
",",
"stop",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"cs",
",",
"err",
"\n",
"}"
] | // CreateClient creates a new client to access the Kubernetes API | [
"CreateClient",
"creates",
"a",
"new",
"client",
"to",
"access",
"the",
"Kubernetes",
"API"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client.go#L89-L116 |
162,324 | cilium/cilium | pkg/k8s/client.go | isConnReady | func isConnReady(c *kubernetes.Clientset) error {
_, err := c.CoreV1().ComponentStatuses().Get("controller-manager", metav1.GetOptions{})
return err
} | go | func isConnReady(c *kubernetes.Clientset) error {
_, err := c.CoreV1().ComponentStatuses().Get("controller-manager", metav1.GetOptions{})
return err
} | [
"func",
"isConnReady",
"(",
"c",
"*",
"kubernetes",
".",
"Clientset",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"CoreV1",
"(",
")",
".",
"ComponentStatuses",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
",",
"metav1",
".",
"GetOptions",
"{",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // isConnReady returns the err for the controller-manager status | [
"isConnReady",
"returns",
"the",
"err",
"for",
"the",
"controller",
"-",
"manager",
"status"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client.go#L119-L122 |
162,325 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | getBackendsV2 | func (b *bpfService) getBackendsV2() map[BackendAddrID]ServiceValue {
b.mutex.RLock()
defer b.mutex.RUnlock()
backends := make(map[BackendAddrID]ServiceValue, len(b.backendsV2))
for addrID, backend := range b.backendsV2 {
backends[addrID] = backend
}
return backends
} | go | func (b *bpfService) getBackendsV2() map[BackendAddrID]ServiceValue {
b.mutex.RLock()
defer b.mutex.RUnlock()
backends := make(map[BackendAddrID]ServiceValue, len(b.backendsV2))
for addrID, backend := range b.backendsV2 {
backends[addrID] = backend
}
return backends
} | [
"func",
"(",
"b",
"*",
"bpfService",
")",
"getBackendsV2",
"(",
")",
"map",
"[",
"BackendAddrID",
"]",
"ServiceValue",
"{",
"b",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"b",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"backends",
":=",
"make",
"(",
"map",
"[",
"BackendAddrID",
"]",
"ServiceValue",
",",
"len",
"(",
"b",
".",
"backendsV2",
")",
")",
"\n",
"for",
"addrID",
",",
"backend",
":=",
"range",
"b",
".",
"backendsV2",
"{",
"backends",
"[",
"addrID",
"]",
"=",
"backend",
"\n",
"}",
"\n\n",
"return",
"backends",
"\n",
"}"
] | // getBackendsV2 makes a copy of backendsV2, so that they are safe to use
// after the bpfService lock has been released. | [
"getBackendsV2",
"makes",
"a",
"copy",
"of",
"backendsV2",
"so",
"that",
"they",
"are",
"safe",
"to",
"use",
"after",
"the",
"bpfService",
"lock",
"has",
"been",
"released",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L166-L176 |
162,326 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | restoreService | func (l *lbmapCache) restoreService(svc loadbalancer.LBSVC, v2Exists bool) error {
l.mutex.Lock()
defer l.mutex.Unlock()
serviceKey, serviceValues, err := LBSVC2ServiceKeynValue(svc)
if err != nil {
return err
}
frontendID := serviceKey.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
bpfSvc = newBpfService(serviceKey)
l.entries[frontendID] = bpfSvc
}
if option.Config.EnableLegacyServices {
for index, backend := range serviceValues {
b := &bpfBackend{
id: backend.BackendAddrID(),
bpfValue: backend,
}
if _, ok := bpfSvc.uniqueBackends[backend.BackendAddrID()]; ok {
b.isHole = true
} else {
bpfSvc.uniqueBackends[backend.BackendAddrID()] = backend
bpfSvc.slaveSlotByBackendAddrID[backend.BackendAddrID()] = index + 1
}
bpfSvc.backendsByMapIndex[index+1] = b
}
}
if !option.Config.EnableLegacyServices || v2Exists {
for _, backend := range serviceValues {
addrID := backend.BackendAddrID()
if _, found := bpfSvc.backendsV2[addrID]; !found {
l.addBackendV2Locked(addrID)
}
bpfSvc.backendsV2[addrID] = backend
}
}
return nil
} | go | func (l *lbmapCache) restoreService(svc loadbalancer.LBSVC, v2Exists bool) error {
l.mutex.Lock()
defer l.mutex.Unlock()
serviceKey, serviceValues, err := LBSVC2ServiceKeynValue(svc)
if err != nil {
return err
}
frontendID := serviceKey.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
bpfSvc = newBpfService(serviceKey)
l.entries[frontendID] = bpfSvc
}
if option.Config.EnableLegacyServices {
for index, backend := range serviceValues {
b := &bpfBackend{
id: backend.BackendAddrID(),
bpfValue: backend,
}
if _, ok := bpfSvc.uniqueBackends[backend.BackendAddrID()]; ok {
b.isHole = true
} else {
bpfSvc.uniqueBackends[backend.BackendAddrID()] = backend
bpfSvc.slaveSlotByBackendAddrID[backend.BackendAddrID()] = index + 1
}
bpfSvc.backendsByMapIndex[index+1] = b
}
}
if !option.Config.EnableLegacyServices || v2Exists {
for _, backend := range serviceValues {
addrID := backend.BackendAddrID()
if _, found := bpfSvc.backendsV2[addrID]; !found {
l.addBackendV2Locked(addrID)
}
bpfSvc.backendsV2[addrID] = backend
}
}
return nil
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"restoreService",
"(",
"svc",
"loadbalancer",
".",
"LBSVC",
",",
"v2Exists",
"bool",
")",
"error",
"{",
"l",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"serviceKey",
",",
"serviceValues",
",",
"err",
":=",
"LBSVC2ServiceKeynValue",
"(",
"svc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"frontendID",
":=",
"serviceKey",
".",
"String",
"(",
")",
"\n\n",
"bpfSvc",
",",
"ok",
":=",
"l",
".",
"entries",
"[",
"frontendID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"bpfSvc",
"=",
"newBpfService",
"(",
"serviceKey",
")",
"\n",
"l",
".",
"entries",
"[",
"frontendID",
"]",
"=",
"bpfSvc",
"\n",
"}",
"\n\n",
"if",
"option",
".",
"Config",
".",
"EnableLegacyServices",
"{",
"for",
"index",
",",
"backend",
":=",
"range",
"serviceValues",
"{",
"b",
":=",
"&",
"bpfBackend",
"{",
"id",
":",
"backend",
".",
"BackendAddrID",
"(",
")",
",",
"bpfValue",
":",
"backend",
",",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"bpfSvc",
".",
"uniqueBackends",
"[",
"backend",
".",
"BackendAddrID",
"(",
")",
"]",
";",
"ok",
"{",
"b",
".",
"isHole",
"=",
"true",
"\n",
"}",
"else",
"{",
"bpfSvc",
".",
"uniqueBackends",
"[",
"backend",
".",
"BackendAddrID",
"(",
")",
"]",
"=",
"backend",
"\n",
"bpfSvc",
".",
"slaveSlotByBackendAddrID",
"[",
"backend",
".",
"BackendAddrID",
"(",
")",
"]",
"=",
"index",
"+",
"1",
"\n",
"}",
"\n\n",
"bpfSvc",
".",
"backendsByMapIndex",
"[",
"index",
"+",
"1",
"]",
"=",
"b",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"option",
".",
"Config",
".",
"EnableLegacyServices",
"||",
"v2Exists",
"{",
"for",
"_",
",",
"backend",
":=",
"range",
"serviceValues",
"{",
"addrID",
":=",
"backend",
".",
"BackendAddrID",
"(",
")",
"\n",
"if",
"_",
",",
"found",
":=",
"bpfSvc",
".",
"backendsV2",
"[",
"addrID",
"]",
";",
"!",
"found",
"{",
"l",
".",
"addBackendV2Locked",
"(",
"addrID",
")",
"\n",
"}",
"\n",
"bpfSvc",
".",
"backendsV2",
"[",
"addrID",
"]",
"=",
"backend",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // restoreService restores service cache of the given legacy and v2 service. | [
"restoreService",
"restores",
"service",
"cache",
"of",
"the",
"given",
"legacy",
"and",
"v2",
"service",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L202-L247 |
162,327 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | prepareUpdate | func (l *lbmapCache) prepareUpdate(fe ServiceKey, backends []ServiceValue) (
*bpfService, map[loadbalancer.BackendID]ServiceValue, []loadbalancer.BackendID, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
frontendID := fe.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
bpfSvc = newBpfService(fe)
l.entries[frontendID] = bpfSvc
}
newBackendsMap := createBackendsMap(backends)
toRemoveBackendIDs := []loadbalancer.BackendID{}
toAddBackendIDs := map[loadbalancer.BackendID]ServiceValue{}
// Step 1: Delete all backends that no longer exist. This will not
// actually remove the backends but overwrite all slave slots that
// point to the removed backend with the backend that has the least
// duplicated slots.
if option.Config.EnableLegacyServices {
for addrID, b := range bpfSvc.uniqueBackends {
if _, ok := newBackendsMap[addrID]; !ok {
bpfSvc.deleteBackend(b)
delete(bpfSvc.slaveSlotByBackendAddrID, addrID)
}
}
}
// Step 2: Delete all backends that no longer exist in the service v2.
for addrID := range bpfSvc.backendsV2 {
if _, ok := newBackendsMap[addrID]; !ok {
isLastInstanceRemoved, err := l.delBackendV2Locked(addrID)
if err != nil {
return nil, nil, nil, err
}
if isLastInstanceRemoved {
toRemoveBackendIDs = append(toRemoveBackendIDs,
l.backendIDByAddrID[addrID])
delete(l.backendIDByAddrID, addrID)
}
delete(bpfSvc.backendsV2, addrID)
}
}
if option.Config.EnableLegacyServices {
// Step 3: Add all backends that don't exist in the legacy service yet.
for _, b := range backends {
if _, ok := bpfSvc.uniqueBackends[b.BackendAddrID()]; !ok {
addrID := b.BackendAddrID()
pos := bpfSvc.addBackend(b)
bpfSvc.slaveSlotByBackendAddrID[addrID] = pos
}
}
}
// Step 4: Add all backends that don't exist in the service v2 yet.
for _, b := range backends {
addrID := b.BackendAddrID()
if _, ok := bpfSvc.backendsV2[addrID]; !ok {
bpfSvc.backendsV2[addrID] = b
isNew := l.addBackendV2Locked(addrID)
if isNew {
toAddBackendIDs[l.backendIDByAddrID[addrID]] = b
}
}
}
return bpfSvc, toAddBackendIDs, toRemoveBackendIDs, nil
} | go | func (l *lbmapCache) prepareUpdate(fe ServiceKey, backends []ServiceValue) (
*bpfService, map[loadbalancer.BackendID]ServiceValue, []loadbalancer.BackendID, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
frontendID := fe.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
bpfSvc = newBpfService(fe)
l.entries[frontendID] = bpfSvc
}
newBackendsMap := createBackendsMap(backends)
toRemoveBackendIDs := []loadbalancer.BackendID{}
toAddBackendIDs := map[loadbalancer.BackendID]ServiceValue{}
// Step 1: Delete all backends that no longer exist. This will not
// actually remove the backends but overwrite all slave slots that
// point to the removed backend with the backend that has the least
// duplicated slots.
if option.Config.EnableLegacyServices {
for addrID, b := range bpfSvc.uniqueBackends {
if _, ok := newBackendsMap[addrID]; !ok {
bpfSvc.deleteBackend(b)
delete(bpfSvc.slaveSlotByBackendAddrID, addrID)
}
}
}
// Step 2: Delete all backends that no longer exist in the service v2.
for addrID := range bpfSvc.backendsV2 {
if _, ok := newBackendsMap[addrID]; !ok {
isLastInstanceRemoved, err := l.delBackendV2Locked(addrID)
if err != nil {
return nil, nil, nil, err
}
if isLastInstanceRemoved {
toRemoveBackendIDs = append(toRemoveBackendIDs,
l.backendIDByAddrID[addrID])
delete(l.backendIDByAddrID, addrID)
}
delete(bpfSvc.backendsV2, addrID)
}
}
if option.Config.EnableLegacyServices {
// Step 3: Add all backends that don't exist in the legacy service yet.
for _, b := range backends {
if _, ok := bpfSvc.uniqueBackends[b.BackendAddrID()]; !ok {
addrID := b.BackendAddrID()
pos := bpfSvc.addBackend(b)
bpfSvc.slaveSlotByBackendAddrID[addrID] = pos
}
}
}
// Step 4: Add all backends that don't exist in the service v2 yet.
for _, b := range backends {
addrID := b.BackendAddrID()
if _, ok := bpfSvc.backendsV2[addrID]; !ok {
bpfSvc.backendsV2[addrID] = b
isNew := l.addBackendV2Locked(addrID)
if isNew {
toAddBackendIDs[l.backendIDByAddrID[addrID]] = b
}
}
}
return bpfSvc, toAddBackendIDs, toRemoveBackendIDs, nil
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"prepareUpdate",
"(",
"fe",
"ServiceKey",
",",
"backends",
"[",
"]",
"ServiceValue",
")",
"(",
"*",
"bpfService",
",",
"map",
"[",
"loadbalancer",
".",
"BackendID",
"]",
"ServiceValue",
",",
"[",
"]",
"loadbalancer",
".",
"BackendID",
",",
"error",
")",
"{",
"l",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"frontendID",
":=",
"fe",
".",
"String",
"(",
")",
"\n\n",
"bpfSvc",
",",
"ok",
":=",
"l",
".",
"entries",
"[",
"frontendID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"bpfSvc",
"=",
"newBpfService",
"(",
"fe",
")",
"\n",
"l",
".",
"entries",
"[",
"frontendID",
"]",
"=",
"bpfSvc",
"\n",
"}",
"\n\n",
"newBackendsMap",
":=",
"createBackendsMap",
"(",
"backends",
")",
"\n",
"toRemoveBackendIDs",
":=",
"[",
"]",
"loadbalancer",
".",
"BackendID",
"{",
"}",
"\n",
"toAddBackendIDs",
":=",
"map",
"[",
"loadbalancer",
".",
"BackendID",
"]",
"ServiceValue",
"{",
"}",
"\n\n",
"// Step 1: Delete all backends that no longer exist. This will not",
"// actually remove the backends but overwrite all slave slots that",
"// point to the removed backend with the backend that has the least",
"// duplicated slots.",
"if",
"option",
".",
"Config",
".",
"EnableLegacyServices",
"{",
"for",
"addrID",
",",
"b",
":=",
"range",
"bpfSvc",
".",
"uniqueBackends",
"{",
"if",
"_",
",",
"ok",
":=",
"newBackendsMap",
"[",
"addrID",
"]",
";",
"!",
"ok",
"{",
"bpfSvc",
".",
"deleteBackend",
"(",
"b",
")",
"\n",
"delete",
"(",
"bpfSvc",
".",
"slaveSlotByBackendAddrID",
",",
"addrID",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"// Step 2: Delete all backends that no longer exist in the service v2.",
"for",
"addrID",
":=",
"range",
"bpfSvc",
".",
"backendsV2",
"{",
"if",
"_",
",",
"ok",
":=",
"newBackendsMap",
"[",
"addrID",
"]",
";",
"!",
"ok",
"{",
"isLastInstanceRemoved",
",",
"err",
":=",
"l",
".",
"delBackendV2Locked",
"(",
"addrID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"isLastInstanceRemoved",
"{",
"toRemoveBackendIDs",
"=",
"append",
"(",
"toRemoveBackendIDs",
",",
"l",
".",
"backendIDByAddrID",
"[",
"addrID",
"]",
")",
"\n",
"delete",
"(",
"l",
".",
"backendIDByAddrID",
",",
"addrID",
")",
"\n",
"}",
"\n",
"delete",
"(",
"bpfSvc",
".",
"backendsV2",
",",
"addrID",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"option",
".",
"Config",
".",
"EnableLegacyServices",
"{",
"// Step 3: Add all backends that don't exist in the legacy service yet.",
"for",
"_",
",",
"b",
":=",
"range",
"backends",
"{",
"if",
"_",
",",
"ok",
":=",
"bpfSvc",
".",
"uniqueBackends",
"[",
"b",
".",
"BackendAddrID",
"(",
")",
"]",
";",
"!",
"ok",
"{",
"addrID",
":=",
"b",
".",
"BackendAddrID",
"(",
")",
"\n",
"pos",
":=",
"bpfSvc",
".",
"addBackend",
"(",
"b",
")",
"\n",
"bpfSvc",
".",
"slaveSlotByBackendAddrID",
"[",
"addrID",
"]",
"=",
"pos",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"// Step 4: Add all backends that don't exist in the service v2 yet.",
"for",
"_",
",",
"b",
":=",
"range",
"backends",
"{",
"addrID",
":=",
"b",
".",
"BackendAddrID",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"bpfSvc",
".",
"backendsV2",
"[",
"addrID",
"]",
";",
"!",
"ok",
"{",
"bpfSvc",
".",
"backendsV2",
"[",
"addrID",
"]",
"=",
"b",
"\n",
"isNew",
":=",
"l",
".",
"addBackendV2Locked",
"(",
"addrID",
")",
"\n",
"if",
"isNew",
"{",
"toAddBackendIDs",
"[",
"l",
".",
"backendIDByAddrID",
"[",
"addrID",
"]",
"]",
"=",
"b",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"bpfSvc",
",",
"toAddBackendIDs",
",",
"toRemoveBackendIDs",
",",
"nil",
"\n",
"}"
] | // prepareUpdate prepares the caches to reflect the changes in the given svc.
// The given backends should not contain a service value of a master service. | [
"prepareUpdate",
"prepares",
"the",
"caches",
"to",
"reflect",
"the",
"changes",
"in",
"the",
"given",
"svc",
".",
"The",
"given",
"backends",
"should",
"not",
"contain",
"a",
"service",
"value",
"of",
"a",
"master",
"service",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L251-L320 |
162,328 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | addBackendV2Locked | func (l *lbmapCache) addBackendV2Locked(addrID BackendAddrID) bool {
l.backendRefCount[addrID]++
return l.backendRefCount[addrID] == 1
} | go | func (l *lbmapCache) addBackendV2Locked(addrID BackendAddrID) bool {
l.backendRefCount[addrID]++
return l.backendRefCount[addrID] == 1
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"addBackendV2Locked",
"(",
"addrID",
"BackendAddrID",
")",
"bool",
"{",
"l",
".",
"backendRefCount",
"[",
"addrID",
"]",
"++",
"\n",
"return",
"l",
".",
"backendRefCount",
"[",
"addrID",
"]",
"==",
"1",
"\n",
"}"
] | // addBackendV2Locked increments a ref count for the given backend and returns
// whether any instance of the backend existed before. | [
"addBackendV2Locked",
"increments",
"a",
"ref",
"count",
"for",
"the",
"given",
"backend",
"and",
"returns",
"whether",
"any",
"instance",
"of",
"the",
"backend",
"existed",
"before",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L348-L351 |
162,329 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | delBackendV2Locked | func (l *lbmapCache) delBackendV2Locked(addrID BackendAddrID) (bool, error) {
count, found := l.backendRefCount[addrID]
if !found {
return false, fmt.Errorf("backend %s not found", addrID)
}
if count == 1 {
delete(l.backendRefCount, addrID)
return true, nil
}
l.backendRefCount[addrID]--
return false, nil
} | go | func (l *lbmapCache) delBackendV2Locked(addrID BackendAddrID) (bool, error) {
count, found := l.backendRefCount[addrID]
if !found {
return false, fmt.Errorf("backend %s not found", addrID)
}
if count == 1 {
delete(l.backendRefCount, addrID)
return true, nil
}
l.backendRefCount[addrID]--
return false, nil
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"delBackendV2Locked",
"(",
"addrID",
"BackendAddrID",
")",
"(",
"bool",
",",
"error",
")",
"{",
"count",
",",
"found",
":=",
"l",
".",
"backendRefCount",
"[",
"addrID",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"addrID",
")",
"\n",
"}",
"\n\n",
"if",
"count",
"==",
"1",
"{",
"delete",
"(",
"l",
".",
"backendRefCount",
",",
"addrID",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"l",
".",
"backendRefCount",
"[",
"addrID",
"]",
"--",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // delBackendV2Locked decrements a ref count for the given backend aand returns
// whether there are any instance of the backend left. | [
"delBackendV2Locked",
"decrements",
"a",
"ref",
"count",
"for",
"the",
"given",
"backend",
"aand",
"returns",
"whether",
"there",
"are",
"any",
"instance",
"of",
"the",
"backend",
"left",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L355-L368 |
162,330 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | removeServiceV2 | func (l *lbmapCache) removeServiceV2(svcKey ServiceKeyV2) ([]loadbalancer.BackendID, int, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
frontendID := svcKey.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
return nil, 0, fmt.Errorf("Service %s not found", frontendID)
}
backendsToRemove := []loadbalancer.BackendID{}
count := len(bpfSvc.backendsV2)
for addrID := range bpfSvc.backendsV2 {
isLastInstance, err := l.delBackendV2Locked(addrID)
if err != nil {
return nil, 0, err
}
if isLastInstance {
backendsToRemove = append(backendsToRemove, l.backendIDByAddrID[addrID])
delete(l.backendIDByAddrID, addrID)
}
}
// FIXME(brb) uncomment the following line after we have removed the support for
// legacy svc.
//delete(l.entries, frontendID)
return backendsToRemove, count, nil
} | go | func (l *lbmapCache) removeServiceV2(svcKey ServiceKeyV2) ([]loadbalancer.BackendID, int, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
frontendID := svcKey.String()
bpfSvc, ok := l.entries[frontendID]
if !ok {
return nil, 0, fmt.Errorf("Service %s not found", frontendID)
}
backendsToRemove := []loadbalancer.BackendID{}
count := len(bpfSvc.backendsV2)
for addrID := range bpfSvc.backendsV2 {
isLastInstance, err := l.delBackendV2Locked(addrID)
if err != nil {
return nil, 0, err
}
if isLastInstance {
backendsToRemove = append(backendsToRemove, l.backendIDByAddrID[addrID])
delete(l.backendIDByAddrID, addrID)
}
}
// FIXME(brb) uncomment the following line after we have removed the support for
// legacy svc.
//delete(l.entries, frontendID)
return backendsToRemove, count, nil
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"removeServiceV2",
"(",
"svcKey",
"ServiceKeyV2",
")",
"(",
"[",
"]",
"loadbalancer",
".",
"BackendID",
",",
"int",
",",
"error",
")",
"{",
"l",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"frontendID",
":=",
"svcKey",
".",
"String",
"(",
")",
"\n",
"bpfSvc",
",",
"ok",
":=",
"l",
".",
"entries",
"[",
"frontendID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"frontendID",
")",
"\n",
"}",
"\n\n",
"backendsToRemove",
":=",
"[",
"]",
"loadbalancer",
".",
"BackendID",
"{",
"}",
"\n",
"count",
":=",
"len",
"(",
"bpfSvc",
".",
"backendsV2",
")",
"\n\n",
"for",
"addrID",
":=",
"range",
"bpfSvc",
".",
"backendsV2",
"{",
"isLastInstance",
",",
"err",
":=",
"l",
".",
"delBackendV2Locked",
"(",
"addrID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"if",
"isLastInstance",
"{",
"backendsToRemove",
"=",
"append",
"(",
"backendsToRemove",
",",
"l",
".",
"backendIDByAddrID",
"[",
"addrID",
"]",
")",
"\n",
"delete",
"(",
"l",
".",
"backendIDByAddrID",
",",
"addrID",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// FIXME(brb) uncomment the following line after we have removed the support for",
"// legacy svc.",
"//delete(l.entries, frontendID)",
"return",
"backendsToRemove",
",",
"count",
",",
"nil",
"\n",
"}"
] | // removeServiceV2 removes the service v2 from the cache. | [
"removeServiceV2",
"removes",
"the",
"service",
"v2",
"from",
"the",
"cache",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L404-L433 |
162,331 | cilium/cilium | pkg/maps/lbmap/bpfservice.go | removeBackendsWithRefCountZero | func (l *lbmapCache) removeBackendsWithRefCountZero() map[BackendAddrID]loadbalancer.BackendID {
l.mutex.Lock()
defer l.mutex.Unlock()
removed := make(map[BackendAddrID]loadbalancer.BackendID)
for addrID, id := range l.backendIDByAddrID {
if l.backendRefCount[addrID] == 0 {
delete(l.backendIDByAddrID, addrID)
removed[addrID] = id
}
}
return removed
} | go | func (l *lbmapCache) removeBackendsWithRefCountZero() map[BackendAddrID]loadbalancer.BackendID {
l.mutex.Lock()
defer l.mutex.Unlock()
removed := make(map[BackendAddrID]loadbalancer.BackendID)
for addrID, id := range l.backendIDByAddrID {
if l.backendRefCount[addrID] == 0 {
delete(l.backendIDByAddrID, addrID)
removed[addrID] = id
}
}
return removed
} | [
"func",
"(",
"l",
"*",
"lbmapCache",
")",
"removeBackendsWithRefCountZero",
"(",
")",
"map",
"[",
"BackendAddrID",
"]",
"loadbalancer",
".",
"BackendID",
"{",
"l",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"removed",
":=",
"make",
"(",
"map",
"[",
"BackendAddrID",
"]",
"loadbalancer",
".",
"BackendID",
")",
"\n\n",
"for",
"addrID",
",",
"id",
":=",
"range",
"l",
".",
"backendIDByAddrID",
"{",
"if",
"l",
".",
"backendRefCount",
"[",
"addrID",
"]",
"==",
"0",
"{",
"delete",
"(",
"l",
".",
"backendIDByAddrID",
",",
"addrID",
")",
"\n",
"removed",
"[",
"addrID",
"]",
"=",
"id",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"removed",
"\n",
"}"
] | // removeBackendsWithRefCountZero removes backends from the cache which are not
// used by any service. | [
"removeBackendsWithRefCountZero",
"removes",
"backends",
"from",
"the",
"cache",
"which",
"are",
"not",
"used",
"by",
"any",
"service",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/lbmap/bpfservice.go#L437-L451 |
162,332 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_id_parameters.go | bindCidr | func (o *GetFqdnCacheIDParams) bindCidr(rawData []string, hasKey bool, formats strfmt.Registry) error {
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
// Required: false
// AllowEmptyValue: false
if raw == "" { // empty values pass all other validations
return nil
}
o.Cidr = &raw
return nil
} | go | func (o *GetFqdnCacheIDParams) bindCidr(rawData []string, hasKey bool, formats strfmt.Registry) error {
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
// Required: false
// AllowEmptyValue: false
if raw == "" { // empty values pass all other validations
return nil
}
o.Cidr = &raw
return nil
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheIDParams",
")",
"bindCidr",
"(",
"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: false",
"// AllowEmptyValue: false",
"if",
"raw",
"==",
"\"",
"\"",
"{",
"// empty values pass all other validations",
"return",
"nil",
"\n",
"}",
"\n\n",
"o",
".",
"Cidr",
"=",
"&",
"raw",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // bindCidr binds and validates parameter Cidr from query. | [
"bindCidr",
"binds",
"and",
"validates",
"parameter",
"Cidr",
"from",
"query",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_id_parameters.go#L94-L109 |
162,333 | cilium/cilium | pkg/envoy/accesslog_server.go | StartAccessLogServer | func StartAccessLogServer(stateDir string, xdsServer *XDSServer, endpointInfoRegistry logger.EndpointInfoRegistry) {
accessLogPath := getAccessLogPath(stateDir)
// Create the access log listener
os.Remove(accessLogPath) // Remove/Unlink the old unix domain socket, if any.
accessLogListener, err := net.ListenUnix("unixpacket", &net.UnixAddr{Name: accessLogPath, Net: "unixpacket"})
if err != nil {
log.WithError(err).Fatalf("Envoy: Failed to open access log listen socket at %s", accessLogPath)
}
accessLogListener.SetUnlinkOnClose(true)
// Make the socket accessible by non-root Envoy proxies, e.g. running in
// sidecar containers.
if err = os.Chmod(accessLogPath, 0777); err != nil {
log.WithError(err).Fatalf("Envoy: Failed to change mode of access log listen socket at %s", accessLogPath)
}
server := accessLogServer{
xdsServer: xdsServer,
endpointInfoRegistry: endpointInfoRegistry,
}
go func() {
for {
// Each Envoy listener opens a new connection over the Unix domain socket.
// Multiple worker threads serving the listener share that same connection
uc, err := accessLogListener.AcceptUnix()
if err != nil {
// These errors are expected when we are closing down
if strings.Contains(err.Error(), "closed network connection") ||
strings.Contains(err.Error(), "invalid argument") {
break
}
log.WithError(err).Warn("Envoy: Failed to accept access log connection")
continue
}
log.Info("Envoy: Accepted access log connection")
// Serve this access log socket in a goroutine, so we can serve multiple
// connections concurrently.
go server.accessLogger(uc)
}
}()
} | go | func StartAccessLogServer(stateDir string, xdsServer *XDSServer, endpointInfoRegistry logger.EndpointInfoRegistry) {
accessLogPath := getAccessLogPath(stateDir)
// Create the access log listener
os.Remove(accessLogPath) // Remove/Unlink the old unix domain socket, if any.
accessLogListener, err := net.ListenUnix("unixpacket", &net.UnixAddr{Name: accessLogPath, Net: "unixpacket"})
if err != nil {
log.WithError(err).Fatalf("Envoy: Failed to open access log listen socket at %s", accessLogPath)
}
accessLogListener.SetUnlinkOnClose(true)
// Make the socket accessible by non-root Envoy proxies, e.g. running in
// sidecar containers.
if err = os.Chmod(accessLogPath, 0777); err != nil {
log.WithError(err).Fatalf("Envoy: Failed to change mode of access log listen socket at %s", accessLogPath)
}
server := accessLogServer{
xdsServer: xdsServer,
endpointInfoRegistry: endpointInfoRegistry,
}
go func() {
for {
// Each Envoy listener opens a new connection over the Unix domain socket.
// Multiple worker threads serving the listener share that same connection
uc, err := accessLogListener.AcceptUnix()
if err != nil {
// These errors are expected when we are closing down
if strings.Contains(err.Error(), "closed network connection") ||
strings.Contains(err.Error(), "invalid argument") {
break
}
log.WithError(err).Warn("Envoy: Failed to accept access log connection")
continue
}
log.Info("Envoy: Accepted access log connection")
// Serve this access log socket in a goroutine, so we can serve multiple
// connections concurrently.
go server.accessLogger(uc)
}
}()
} | [
"func",
"StartAccessLogServer",
"(",
"stateDir",
"string",
",",
"xdsServer",
"*",
"XDSServer",
",",
"endpointInfoRegistry",
"logger",
".",
"EndpointInfoRegistry",
")",
"{",
"accessLogPath",
":=",
"getAccessLogPath",
"(",
"stateDir",
")",
"\n\n",
"// Create the access log listener",
"os",
".",
"Remove",
"(",
"accessLogPath",
")",
"// Remove/Unlink the old unix domain socket, if any.",
"\n",
"accessLogListener",
",",
"err",
":=",
"net",
".",
"ListenUnix",
"(",
"\"",
"\"",
",",
"&",
"net",
".",
"UnixAddr",
"{",
"Name",
":",
"accessLogPath",
",",
"Net",
":",
"\"",
"\"",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"accessLogPath",
")",
"\n",
"}",
"\n",
"accessLogListener",
".",
"SetUnlinkOnClose",
"(",
"true",
")",
"\n\n",
"// Make the socket accessible by non-root Envoy proxies, e.g. running in",
"// sidecar containers.",
"if",
"err",
"=",
"os",
".",
"Chmod",
"(",
"accessLogPath",
",",
"0777",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"accessLogPath",
")",
"\n",
"}",
"\n\n",
"server",
":=",
"accessLogServer",
"{",
"xdsServer",
":",
"xdsServer",
",",
"endpointInfoRegistry",
":",
"endpointInfoRegistry",
",",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"// Each Envoy listener opens a new connection over the Unix domain socket.",
"// Multiple worker threads serving the listener share that same connection",
"uc",
",",
"err",
":=",
"accessLogListener",
".",
"AcceptUnix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// These errors are expected when we are closing down",
"if",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"break",
"\n",
"}",
"\n",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"// Serve this access log socket in a goroutine, so we can serve multiple",
"// connections concurrently.",
"go",
"server",
".",
"accessLogger",
"(",
"uc",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // StartAccessLogServer starts the access log server. | [
"StartAccessLogServer",
"starts",
"the",
"access",
"log",
"server",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/accesslog_server.go#L45-L88 |
162,334 | cilium/cilium | pkg/bpf/stats_linux.go | Duration | func (d *DumpStats) Duration() time.Duration {
return d.Finished.Sub(d.Started)
} | go | func (d *DumpStats) Duration() time.Duration {
return d.Finished.Sub(d.Started)
} | [
"func",
"(",
"d",
"*",
"DumpStats",
")",
"Duration",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"d",
".",
"Finished",
".",
"Sub",
"(",
"d",
".",
"Started",
")",
"\n",
"}"
] | // Duration returns the duration of the dump. | [
"Duration",
"returns",
"the",
"duration",
"of",
"the",
"dump",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/bpf/stats_linux.go#L74-L76 |
162,335 | cilium/cilium | pkg/policy/api/selector.go | LabelSelectorString | func (n *EndpointSelector) LabelSelectorString() string {
if n != nil && n.LabelSelector == nil {
return "<all>"
}
return metav1.FormatLabelSelector(n.LabelSelector)
} | go | func (n *EndpointSelector) LabelSelectorString() string {
if n != nil && n.LabelSelector == nil {
return "<all>"
}
return metav1.FormatLabelSelector(n.LabelSelector)
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"LabelSelectorString",
"(",
")",
"string",
"{",
"if",
"n",
"!=",
"nil",
"&&",
"n",
".",
"LabelSelector",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"metav1",
".",
"FormatLabelSelector",
"(",
"n",
".",
"LabelSelector",
")",
"\n",
"}"
] | // LabelSelectorString returns a user-friendly string representation of
// EndpointSelector. | [
"LabelSelectorString",
"returns",
"a",
"user",
"-",
"friendly",
"string",
"representation",
"of",
"EndpointSelector",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L46-L51 |
162,336 | cilium/cilium | pkg/policy/api/selector.go | String | func (n EndpointSelector) String() string {
j, _ := n.MarshalJSON()
return string(j)
} | go | func (n EndpointSelector) String() string {
j, _ := n.MarshalJSON()
return string(j)
} | [
"func",
"(",
"n",
"EndpointSelector",
")",
"String",
"(",
")",
"string",
"{",
"j",
",",
"_",
":=",
"n",
".",
"MarshalJSON",
"(",
")",
"\n",
"return",
"string",
"(",
"j",
")",
"\n",
"}"
] | // String returns a string representation of EndpointSelector. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"EndpointSelector",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L54-L57 |
162,337 | cilium/cilium | pkg/policy/api/selector.go | UnmarshalJSON | func (n *EndpointSelector) UnmarshalJSON(b []byte) error {
n.LabelSelector = &metav1.LabelSelector{}
err := json.Unmarshal(b, n.LabelSelector)
if err != nil {
return err
}
if n.MatchLabels != nil {
ml := map[string]string{}
for k, v := range n.MatchLabels {
ml[labels.GetExtendedKeyFrom(k)] = v
}
n.MatchLabels = ml
}
if n.MatchExpressions != nil {
newMatchExpr := make([]metav1.LabelSelectorRequirement, len(n.MatchExpressions))
for i, v := range n.MatchExpressions {
v.Key = labels.GetExtendedKeyFrom(v.Key)
newMatchExpr[i] = v
}
n.MatchExpressions = newMatchExpr
}
n.requirements = labelSelectorToRequirements(n.LabelSelector)
return nil
} | go | func (n *EndpointSelector) UnmarshalJSON(b []byte) error {
n.LabelSelector = &metav1.LabelSelector{}
err := json.Unmarshal(b, n.LabelSelector)
if err != nil {
return err
}
if n.MatchLabels != nil {
ml := map[string]string{}
for k, v := range n.MatchLabels {
ml[labels.GetExtendedKeyFrom(k)] = v
}
n.MatchLabels = ml
}
if n.MatchExpressions != nil {
newMatchExpr := make([]metav1.LabelSelectorRequirement, len(n.MatchExpressions))
for i, v := range n.MatchExpressions {
v.Key = labels.GetExtendedKeyFrom(v.Key)
newMatchExpr[i] = v
}
n.MatchExpressions = newMatchExpr
}
n.requirements = labelSelectorToRequirements(n.LabelSelector)
return nil
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"n",
".",
"LabelSelector",
"=",
"&",
"metav1",
".",
"LabelSelector",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"n",
".",
"LabelSelector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"n",
".",
"MatchLabels",
"!=",
"nil",
"{",
"ml",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"n",
".",
"MatchLabels",
"{",
"ml",
"[",
"labels",
".",
"GetExtendedKeyFrom",
"(",
"k",
")",
"]",
"=",
"v",
"\n",
"}",
"\n",
"n",
".",
"MatchLabels",
"=",
"ml",
"\n",
"}",
"\n",
"if",
"n",
".",
"MatchExpressions",
"!=",
"nil",
"{",
"newMatchExpr",
":=",
"make",
"(",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
",",
"len",
"(",
"n",
".",
"MatchExpressions",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"n",
".",
"MatchExpressions",
"{",
"v",
".",
"Key",
"=",
"labels",
".",
"GetExtendedKeyFrom",
"(",
"v",
".",
"Key",
")",
"\n",
"newMatchExpr",
"[",
"i",
"]",
"=",
"v",
"\n",
"}",
"\n",
"n",
".",
"MatchExpressions",
"=",
"newMatchExpr",
"\n",
"}",
"\n",
"n",
".",
"requirements",
"=",
"labelSelectorToRequirements",
"(",
"n",
".",
"LabelSelector",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON unmarshals the endpoint selector from the byte array. | [
"UnmarshalJSON",
"unmarshals",
"the",
"endpoint",
"selector",
"from",
"the",
"byte",
"array",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L60-L83 |
162,338 | cilium/cilium | pkg/policy/api/selector.go | MarshalJSON | func (n EndpointSelector) MarshalJSON() ([]byte, error) {
ls := metav1.LabelSelector{}
if n.LabelSelector == nil {
return json.Marshal(ls)
}
if n.MatchLabels != nil {
newLabels := map[string]string{}
for k, v := range n.MatchLabels {
newLabels[labels.GetCiliumKeyFrom(k)] = v
}
ls.MatchLabels = newLabels
}
if n.MatchExpressions != nil {
newMatchExpr := make([]metav1.LabelSelectorRequirement, len(n.MatchExpressions))
for i, v := range n.MatchExpressions {
v.Key = labels.GetCiliumKeyFrom(v.Key)
newMatchExpr[i] = v
}
ls.MatchExpressions = newMatchExpr
}
return json.Marshal(ls)
} | go | func (n EndpointSelector) MarshalJSON() ([]byte, error) {
ls := metav1.LabelSelector{}
if n.LabelSelector == nil {
return json.Marshal(ls)
}
if n.MatchLabels != nil {
newLabels := map[string]string{}
for k, v := range n.MatchLabels {
newLabels[labels.GetCiliumKeyFrom(k)] = v
}
ls.MatchLabels = newLabels
}
if n.MatchExpressions != nil {
newMatchExpr := make([]metav1.LabelSelectorRequirement, len(n.MatchExpressions))
for i, v := range n.MatchExpressions {
v.Key = labels.GetCiliumKeyFrom(v.Key)
newMatchExpr[i] = v
}
ls.MatchExpressions = newMatchExpr
}
return json.Marshal(ls)
} | [
"func",
"(",
"n",
"EndpointSelector",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"ls",
":=",
"metav1",
".",
"LabelSelector",
"{",
"}",
"\n\n",
"if",
"n",
".",
"LabelSelector",
"==",
"nil",
"{",
"return",
"json",
".",
"Marshal",
"(",
"ls",
")",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"MatchLabels",
"!=",
"nil",
"{",
"newLabels",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"n",
".",
"MatchLabels",
"{",
"newLabels",
"[",
"labels",
".",
"GetCiliumKeyFrom",
"(",
"k",
")",
"]",
"=",
"v",
"\n",
"}",
"\n",
"ls",
".",
"MatchLabels",
"=",
"newLabels",
"\n",
"}",
"\n",
"if",
"n",
".",
"MatchExpressions",
"!=",
"nil",
"{",
"newMatchExpr",
":=",
"make",
"(",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
",",
"len",
"(",
"n",
".",
"MatchExpressions",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"n",
".",
"MatchExpressions",
"{",
"v",
".",
"Key",
"=",
"labels",
".",
"GetCiliumKeyFrom",
"(",
"v",
".",
"Key",
")",
"\n",
"newMatchExpr",
"[",
"i",
"]",
"=",
"v",
"\n",
"}",
"\n",
"ls",
".",
"MatchExpressions",
"=",
"newMatchExpr",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"ls",
")",
"\n",
"}"
] | // MarshalJSON returns a JSON representation of the byte array. | [
"MarshalJSON",
"returns",
"a",
"JSON",
"representation",
"of",
"the",
"byte",
"array",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L86-L109 |
162,339 | cilium/cilium | pkg/policy/api/selector.go | HasKeyPrefix | func (n EndpointSelector) HasKeyPrefix(prefix string) bool {
for k := range n.MatchLabels {
if strings.HasPrefix(k, prefix) {
return true
}
}
for _, v := range n.MatchExpressions {
if strings.HasPrefix(v.Key, prefix) {
return true
}
}
return false
} | go | func (n EndpointSelector) HasKeyPrefix(prefix string) bool {
for k := range n.MatchLabels {
if strings.HasPrefix(k, prefix) {
return true
}
}
for _, v := range n.MatchExpressions {
if strings.HasPrefix(v.Key, prefix) {
return true
}
}
return false
} | [
"func",
"(",
"n",
"EndpointSelector",
")",
"HasKeyPrefix",
"(",
"prefix",
"string",
")",
"bool",
"{",
"for",
"k",
":=",
"range",
"n",
".",
"MatchLabels",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"k",
",",
"prefix",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"n",
".",
"MatchExpressions",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"v",
".",
"Key",
",",
"prefix",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // HasKeyPrefix checks if the endpoint selector contains the given key prefix in
// its MatchLabels map and MatchExpressions slice. | [
"HasKeyPrefix",
"checks",
"if",
"the",
"endpoint",
"selector",
"contains",
"the",
"given",
"key",
"prefix",
"in",
"its",
"MatchLabels",
"map",
"and",
"MatchExpressions",
"slice",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L113-L125 |
162,340 | cilium/cilium | pkg/policy/api/selector.go | HasKey | func (n EndpointSelector) HasKey(key string) bool {
if _, ok := n.MatchLabels[key]; ok {
return true
}
for _, v := range n.MatchExpressions {
if v.Key == key {
return true
}
}
return false
} | go | func (n EndpointSelector) HasKey(key string) bool {
if _, ok := n.MatchLabels[key]; ok {
return true
}
for _, v := range n.MatchExpressions {
if v.Key == key {
return true
}
}
return false
} | [
"func",
"(",
"n",
"EndpointSelector",
")",
"HasKey",
"(",
"key",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"n",
".",
"MatchLabels",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"n",
".",
"MatchExpressions",
"{",
"if",
"v",
".",
"Key",
"==",
"key",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // HasKey checks if the endpoint selector contains the given key in
// its MatchLabels map or in its MatchExpressions slice. | [
"HasKey",
"checks",
"if",
"the",
"endpoint",
"selector",
"contains",
"the",
"given",
"key",
"in",
"its",
"MatchLabels",
"map",
"or",
"in",
"its",
"MatchExpressions",
"slice",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L129-L139 |
162,341 | cilium/cilium | pkg/policy/api/selector.go | GetMatch | func (n EndpointSelector) GetMatch(key string) ([]string, bool) {
if value, ok := n.MatchLabels[key]; ok {
return []string{value}, true
}
for _, v := range n.MatchExpressions {
if v.Key == key && v.Operator == metav1.LabelSelectorOpIn {
return v.Values, true
}
}
return nil, false
} | go | func (n EndpointSelector) GetMatch(key string) ([]string, bool) {
if value, ok := n.MatchLabels[key]; ok {
return []string{value}, true
}
for _, v := range n.MatchExpressions {
if v.Key == key && v.Operator == metav1.LabelSelectorOpIn {
return v.Values, true
}
}
return nil, false
} | [
"func",
"(",
"n",
"EndpointSelector",
")",
"GetMatch",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"string",
",",
"bool",
")",
"{",
"if",
"value",
",",
"ok",
":=",
"n",
".",
"MatchLabels",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"[",
"]",
"string",
"{",
"value",
"}",
",",
"true",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"n",
".",
"MatchExpressions",
"{",
"if",
"v",
".",
"Key",
"==",
"key",
"&&",
"v",
".",
"Operator",
"==",
"metav1",
".",
"LabelSelectorOpIn",
"{",
"return",
"v",
".",
"Values",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] | // GetMatch checks for a match on the specified key, and returns the value that
// the key must match, and true. If a match cannot be found, returns nil, false. | [
"GetMatch",
"checks",
"for",
"a",
"match",
"on",
"the",
"specified",
"key",
"and",
"returns",
"the",
"value",
"that",
"the",
"key",
"must",
"match",
"and",
"true",
".",
"If",
"a",
"match",
"cannot",
"be",
"found",
"returns",
"nil",
"false",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L143-L153 |
162,342 | cilium/cilium | pkg/policy/api/selector.go | NewESFromLabels | func NewESFromLabels(lbls ...labels.Label) EndpointSelector {
ml := map[string]string{}
for _, lbl := range lbls {
ml[lbl.GetExtendedKey()] = lbl.Value
}
return NewESFromMatchRequirements(ml, nil)
} | go | func NewESFromLabels(lbls ...labels.Label) EndpointSelector {
ml := map[string]string{}
for _, lbl := range lbls {
ml[lbl.GetExtendedKey()] = lbl.Value
}
return NewESFromMatchRequirements(ml, nil)
} | [
"func",
"NewESFromLabels",
"(",
"lbls",
"...",
"labels",
".",
"Label",
")",
"EndpointSelector",
"{",
"ml",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"lbl",
":=",
"range",
"lbls",
"{",
"ml",
"[",
"lbl",
".",
"GetExtendedKey",
"(",
")",
"]",
"=",
"lbl",
".",
"Value",
"\n",
"}",
"\n\n",
"return",
"NewESFromMatchRequirements",
"(",
"ml",
",",
"nil",
")",
"\n",
"}"
] | // NewESFromLabels creates a new endpoint selector from the given labels. | [
"NewESFromLabels",
"creates",
"a",
"new",
"endpoint",
"selector",
"from",
"the",
"given",
"labels",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L179-L186 |
162,343 | cilium/cilium | pkg/policy/api/selector.go | newReservedEndpointSelector | func newReservedEndpointSelector(ID string) EndpointSelector {
reservedLabels := labels.NewLabel(ID, "", labels.LabelSourceReserved)
return NewESFromLabels(reservedLabels)
} | go | func newReservedEndpointSelector(ID string) EndpointSelector {
reservedLabels := labels.NewLabel(ID, "", labels.LabelSourceReserved)
return NewESFromLabels(reservedLabels)
} | [
"func",
"newReservedEndpointSelector",
"(",
"ID",
"string",
")",
"EndpointSelector",
"{",
"reservedLabels",
":=",
"labels",
".",
"NewLabel",
"(",
"ID",
",",
"\"",
"\"",
",",
"labels",
".",
"LabelSourceReserved",
")",
"\n",
"return",
"NewESFromLabels",
"(",
"reservedLabels",
")",
"\n",
"}"
] | // newReservedEndpointSelector returns a selector that matches on all
// endpoints with the specified reserved label. | [
"newReservedEndpointSelector",
"returns",
"a",
"selector",
"that",
"matches",
"on",
"all",
"endpoints",
"with",
"the",
"specified",
"reserved",
"label",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L216-L219 |
162,344 | cilium/cilium | pkg/policy/api/selector.go | NewESFromK8sLabelSelector | func NewESFromK8sLabelSelector(srcPrefix string, lss ...*metav1.LabelSelector) EndpointSelector {
var (
matchLabels map[string]string
matchExpressions []metav1.LabelSelectorRequirement
)
for _, ls := range lss {
if ls == nil {
continue
}
if ls.MatchLabels != nil {
if matchLabels == nil {
matchLabels = map[string]string{}
}
for k, v := range ls.MatchLabels {
matchLabels[srcPrefix+k] = v
}
}
if ls.MatchExpressions != nil {
if matchExpressions == nil {
matchExpressions = make([]metav1.LabelSelectorRequirement, 0, len(ls.MatchExpressions))
}
for _, v := range ls.MatchExpressions {
v.Key = srcPrefix + v.Key
matchExpressions = append(matchExpressions, v)
}
}
}
return NewESFromMatchRequirements(matchLabels, matchExpressions)
} | go | func NewESFromK8sLabelSelector(srcPrefix string, lss ...*metav1.LabelSelector) EndpointSelector {
var (
matchLabels map[string]string
matchExpressions []metav1.LabelSelectorRequirement
)
for _, ls := range lss {
if ls == nil {
continue
}
if ls.MatchLabels != nil {
if matchLabels == nil {
matchLabels = map[string]string{}
}
for k, v := range ls.MatchLabels {
matchLabels[srcPrefix+k] = v
}
}
if ls.MatchExpressions != nil {
if matchExpressions == nil {
matchExpressions = make([]metav1.LabelSelectorRequirement, 0, len(ls.MatchExpressions))
}
for _, v := range ls.MatchExpressions {
v.Key = srcPrefix + v.Key
matchExpressions = append(matchExpressions, v)
}
}
}
return NewESFromMatchRequirements(matchLabels, matchExpressions)
} | [
"func",
"NewESFromK8sLabelSelector",
"(",
"srcPrefix",
"string",
",",
"lss",
"...",
"*",
"metav1",
".",
"LabelSelector",
")",
"EndpointSelector",
"{",
"var",
"(",
"matchLabels",
"map",
"[",
"string",
"]",
"string",
"\n",
"matchExpressions",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
"\n",
")",
"\n",
"for",
"_",
",",
"ls",
":=",
"range",
"lss",
"{",
"if",
"ls",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"ls",
".",
"MatchLabels",
"!=",
"nil",
"{",
"if",
"matchLabels",
"==",
"nil",
"{",
"matchLabels",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"ls",
".",
"MatchLabels",
"{",
"matchLabels",
"[",
"srcPrefix",
"+",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"ls",
".",
"MatchExpressions",
"!=",
"nil",
"{",
"if",
"matchExpressions",
"==",
"nil",
"{",
"matchExpressions",
"=",
"make",
"(",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
",",
"0",
",",
"len",
"(",
"ls",
".",
"MatchExpressions",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"ls",
".",
"MatchExpressions",
"{",
"v",
".",
"Key",
"=",
"srcPrefix",
"+",
"v",
".",
"Key",
"\n",
"matchExpressions",
"=",
"append",
"(",
"matchExpressions",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"NewESFromMatchRequirements",
"(",
"matchLabels",
",",
"matchExpressions",
")",
"\n",
"}"
] | // NewESFromK8sLabelSelector returns a new endpoint selector from the label
// where it the given srcPrefix will be encoded in the label's keys. | [
"NewESFromK8sLabelSelector",
"returns",
"a",
"new",
"endpoint",
"selector",
"from",
"the",
"label",
"where",
"it",
"the",
"given",
"srcPrefix",
"will",
"be",
"encoded",
"in",
"the",
"label",
"s",
"keys",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L236-L264 |
162,345 | cilium/cilium | pkg/policy/api/selector.go | AddMatch | func (n *EndpointSelector) AddMatch(key, value string) {
if n.MatchLabels == nil {
n.MatchLabels = map[string]string{}
}
n.MatchLabels[key] = value
n.requirements = labelSelectorToRequirements(n.LabelSelector)
} | go | func (n *EndpointSelector) AddMatch(key, value string) {
if n.MatchLabels == nil {
n.MatchLabels = map[string]string{}
}
n.MatchLabels[key] = value
n.requirements = labelSelectorToRequirements(n.LabelSelector)
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"AddMatch",
"(",
"key",
",",
"value",
"string",
")",
"{",
"if",
"n",
".",
"MatchLabels",
"==",
"nil",
"{",
"n",
".",
"MatchLabels",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"n",
".",
"MatchLabels",
"[",
"key",
"]",
"=",
"value",
"\n",
"n",
".",
"requirements",
"=",
"labelSelectorToRequirements",
"(",
"n",
".",
"LabelSelector",
")",
"\n",
"}"
] | // AddMatch adds a match for 'key' == 'value' to the endpoint selector. | [
"AddMatch",
"adds",
"a",
"match",
"for",
"key",
"==",
"value",
"to",
"the",
"endpoint",
"selector",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L267-L273 |
162,346 | cilium/cilium | pkg/policy/api/selector.go | Matches | func (n *EndpointSelector) Matches(lblsToMatch k8sLbls.Labels) bool {
// Try to update cached requirements for this EndpointSelector if possible.
if n.requirements == nil {
n.requirements = labelSelectorToRequirements(n.LabelSelector)
// Nil indicates that requirements failed validation in some way,
// so we cannot parse the labels for matching purposes; thus, we cannot
// match if labels cannot be parsed, so return false.
if n.requirements == nil {
return false
}
}
for k := range n.MatchLabels {
if k == labels.LabelSourceReservedKeyPrefix+labels.IDNameAll {
return true
}
}
for _, req := range *n.requirements {
if !req.Matches(lblsToMatch) {
return false
}
}
return true
} | go | func (n *EndpointSelector) Matches(lblsToMatch k8sLbls.Labels) bool {
// Try to update cached requirements for this EndpointSelector if possible.
if n.requirements == nil {
n.requirements = labelSelectorToRequirements(n.LabelSelector)
// Nil indicates that requirements failed validation in some way,
// so we cannot parse the labels for matching purposes; thus, we cannot
// match if labels cannot be parsed, so return false.
if n.requirements == nil {
return false
}
}
for k := range n.MatchLabels {
if k == labels.LabelSourceReservedKeyPrefix+labels.IDNameAll {
return true
}
}
for _, req := range *n.requirements {
if !req.Matches(lblsToMatch) {
return false
}
}
return true
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"Matches",
"(",
"lblsToMatch",
"k8sLbls",
".",
"Labels",
")",
"bool",
"{",
"// Try to update cached requirements for this EndpointSelector if possible.",
"if",
"n",
".",
"requirements",
"==",
"nil",
"{",
"n",
".",
"requirements",
"=",
"labelSelectorToRequirements",
"(",
"n",
".",
"LabelSelector",
")",
"\n",
"// Nil indicates that requirements failed validation in some way,",
"// so we cannot parse the labels for matching purposes; thus, we cannot",
"// match if labels cannot be parsed, so return false.",
"if",
"n",
".",
"requirements",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"k",
":=",
"range",
"n",
".",
"MatchLabels",
"{",
"if",
"k",
"==",
"labels",
".",
"LabelSourceReservedKeyPrefix",
"+",
"labels",
".",
"IDNameAll",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"req",
":=",
"range",
"*",
"n",
".",
"requirements",
"{",
"if",
"!",
"req",
".",
"Matches",
"(",
"lblsToMatch",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Matches returns true if the endpoint selector Matches the `lblsToMatch`.
// Returns always true if the endpoint selector contains the reserved label for
// "all". | [
"Matches",
"returns",
"true",
"if",
"the",
"endpoint",
"selector",
"Matches",
"the",
"lblsToMatch",
".",
"Returns",
"always",
"true",
"if",
"the",
"endpoint",
"selector",
"contains",
"the",
"reserved",
"label",
"for",
"all",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L278-L303 |
162,347 | cilium/cilium | pkg/policy/api/selector.go | IsWildcard | func (n *EndpointSelector) IsWildcard() bool {
return n.LabelSelector != nil &&
len(n.LabelSelector.MatchLabels)+len(n.LabelSelector.MatchExpressions) == 0
} | go | func (n *EndpointSelector) IsWildcard() bool {
return n.LabelSelector != nil &&
len(n.LabelSelector.MatchLabels)+len(n.LabelSelector.MatchExpressions) == 0
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"IsWildcard",
"(",
")",
"bool",
"{",
"return",
"n",
".",
"LabelSelector",
"!=",
"nil",
"&&",
"len",
"(",
"n",
".",
"LabelSelector",
".",
"MatchLabels",
")",
"+",
"len",
"(",
"n",
".",
"LabelSelector",
".",
"MatchExpressions",
")",
"==",
"0",
"\n",
"}"
] | // IsWildcard returns true if the endpoint selector selects all endpoints. | [
"IsWildcard",
"returns",
"true",
"if",
"the",
"endpoint",
"selector",
"selects",
"all",
"endpoints",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L306-L309 |
162,348 | cilium/cilium | pkg/policy/api/selector.go | ConvertToLabelSelectorRequirementSlice | func (n *EndpointSelector) ConvertToLabelSelectorRequirementSlice() []metav1.LabelSelectorRequirement {
requirements := make([]metav1.LabelSelectorRequirement, 0, len(n.MatchExpressions)+len(n.MatchLabels))
// Append already existing match expressions.
requirements = append(requirements, n.MatchExpressions...)
// Convert each MatchLables to LabelSelectorRequirement.
for key, value := range n.MatchLabels {
requirementFromMatchLabels := metav1.LabelSelectorRequirement{
Key: key,
Operator: metav1.LabelSelectorOpIn,
Values: []string{value},
}
requirements = append(requirements, requirementFromMatchLabels)
}
return requirements
} | go | func (n *EndpointSelector) ConvertToLabelSelectorRequirementSlice() []metav1.LabelSelectorRequirement {
requirements := make([]metav1.LabelSelectorRequirement, 0, len(n.MatchExpressions)+len(n.MatchLabels))
// Append already existing match expressions.
requirements = append(requirements, n.MatchExpressions...)
// Convert each MatchLables to LabelSelectorRequirement.
for key, value := range n.MatchLabels {
requirementFromMatchLabels := metav1.LabelSelectorRequirement{
Key: key,
Operator: metav1.LabelSelectorOpIn,
Values: []string{value},
}
requirements = append(requirements, requirementFromMatchLabels)
}
return requirements
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"ConvertToLabelSelectorRequirementSlice",
"(",
")",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
"{",
"requirements",
":=",
"make",
"(",
"[",
"]",
"metav1",
".",
"LabelSelectorRequirement",
",",
"0",
",",
"len",
"(",
"n",
".",
"MatchExpressions",
")",
"+",
"len",
"(",
"n",
".",
"MatchLabels",
")",
")",
"\n",
"// Append already existing match expressions.",
"requirements",
"=",
"append",
"(",
"requirements",
",",
"n",
".",
"MatchExpressions",
"...",
")",
"\n",
"// Convert each MatchLables to LabelSelectorRequirement.",
"for",
"key",
",",
"value",
":=",
"range",
"n",
".",
"MatchLabels",
"{",
"requirementFromMatchLabels",
":=",
"metav1",
".",
"LabelSelectorRequirement",
"{",
"Key",
":",
"key",
",",
"Operator",
":",
"metav1",
".",
"LabelSelectorOpIn",
",",
"Values",
":",
"[",
"]",
"string",
"{",
"value",
"}",
",",
"}",
"\n",
"requirements",
"=",
"append",
"(",
"requirements",
",",
"requirementFromMatchLabels",
")",
"\n",
"}",
"\n",
"return",
"requirements",
"\n",
"}"
] | // ConvertToLabelSelectorRequirementSlice converts the MatchLabels and
// MatchExpressions within the specified EndpointSelector into a list of
// LabelSelectorRequirements. | [
"ConvertToLabelSelectorRequirementSlice",
"converts",
"the",
"MatchLabels",
"and",
"MatchExpressions",
"within",
"the",
"specified",
"EndpointSelector",
"into",
"a",
"list",
"of",
"LabelSelectorRequirements",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L314-L328 |
162,349 | cilium/cilium | pkg/policy/api/selector.go | sanitize | func (n *EndpointSelector) sanitize() error {
errList := validation.ValidateLabelSelector(n.LabelSelector, nil)
if len(errList) > 0 {
return fmt.Errorf("invalid label selector: %s", errList.ToAggregate().Error())
}
return nil
} | go | func (n *EndpointSelector) sanitize() error {
errList := validation.ValidateLabelSelector(n.LabelSelector, nil)
if len(errList) > 0 {
return fmt.Errorf("invalid label selector: %s", errList.ToAggregate().Error())
}
return nil
} | [
"func",
"(",
"n",
"*",
"EndpointSelector",
")",
"sanitize",
"(",
")",
"error",
"{",
"errList",
":=",
"validation",
".",
"ValidateLabelSelector",
"(",
"n",
".",
"LabelSelector",
",",
"nil",
")",
"\n",
"if",
"len",
"(",
"errList",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errList",
".",
"ToAggregate",
"(",
")",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // sanitize returns an error if the EndpointSelector's LabelSelector is invalid. | [
"sanitize",
"returns",
"an",
"error",
"if",
"the",
"EndpointSelector",
"s",
"LabelSelector",
"is",
"invalid",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L331-L337 |
162,350 | cilium/cilium | pkg/policy/api/selector.go | Matches | func (s EndpointSelectorSlice) Matches(ctx labels.LabelArray) bool {
for _, selector := range s {
if selector.Matches(ctx) {
return true
}
}
return false
} | go | func (s EndpointSelectorSlice) Matches(ctx labels.LabelArray) bool {
for _, selector := range s {
if selector.Matches(ctx) {
return true
}
}
return false
} | [
"func",
"(",
"s",
"EndpointSelectorSlice",
")",
"Matches",
"(",
"ctx",
"labels",
".",
"LabelArray",
")",
"bool",
"{",
"for",
"_",
",",
"selector",
":=",
"range",
"s",
"{",
"if",
"selector",
".",
"Matches",
"(",
"ctx",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Matches returns true if any of the EndpointSelectors in the slice match the
// provided labels | [
"Matches",
"returns",
"true",
"if",
"any",
"of",
"the",
"EndpointSelectors",
"in",
"the",
"slice",
"match",
"the",
"provided",
"labels"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L354-L362 |
162,351 | cilium/cilium | pkg/policy/api/selector.go | SelectsAllEndpoints | func (s EndpointSelectorSlice) SelectsAllEndpoints() bool {
for _, selector := range s {
if selector.IsWildcard() {
return true
}
}
return false
} | go | func (s EndpointSelectorSlice) SelectsAllEndpoints() bool {
for _, selector := range s {
if selector.IsWildcard() {
return true
}
}
return false
} | [
"func",
"(",
"s",
"EndpointSelectorSlice",
")",
"SelectsAllEndpoints",
"(",
")",
"bool",
"{",
"for",
"_",
",",
"selector",
":=",
"range",
"s",
"{",
"if",
"selector",
".",
"IsWildcard",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // SelectsAllEndpoints returns whether the EndpointSelectorSlice selects all
// endpoints, which is true if the wildcard endpoint selector is present in the
// slice. | [
"SelectsAllEndpoints",
"returns",
"whether",
"the",
"EndpointSelectorSlice",
"selects",
"all",
"endpoints",
"which",
"is",
"true",
"if",
"the",
"wildcard",
"endpoint",
"selector",
"is",
"present",
"in",
"the",
"slice",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/selector.go#L367-L374 |
162,352 | cilium/cilium | api/v1/server/restapi/daemon/get_map_name.go | NewGetMapName | func NewGetMapName(ctx *middleware.Context, handler GetMapNameHandler) *GetMapName {
return &GetMapName{Context: ctx, Handler: handler}
} | go | func NewGetMapName(ctx *middleware.Context, handler GetMapNameHandler) *GetMapName {
return &GetMapName{Context: ctx, Handler: handler}
} | [
"func",
"NewGetMapName",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"GetMapNameHandler",
")",
"*",
"GetMapName",
"{",
"return",
"&",
"GetMapName",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewGetMapName creates a new http.Handler for the get map name operation | [
"NewGetMapName",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"get",
"map",
"name",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/daemon/get_map_name.go#L28-L30 |
162,353 | cilium/cilium | pkg/completion/completion.go | NewWaitGroup | func NewWaitGroup(ctx context.Context) *WaitGroup {
ctx2, cancel := context.WithCancel(ctx)
return &WaitGroup{ctx: ctx2, cancel: cancel}
} | go | func NewWaitGroup(ctx context.Context) *WaitGroup {
ctx2, cancel := context.WithCancel(ctx)
return &WaitGroup{ctx: ctx2, cancel: cancel}
} | [
"func",
"NewWaitGroup",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"WaitGroup",
"{",
"ctx2",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"return",
"&",
"WaitGroup",
"{",
"ctx",
":",
"ctx2",
",",
"cancel",
":",
"cancel",
"}",
"\n",
"}"
] | // NewWaitGroup returns a new WaitGroup using the given context. | [
"NewWaitGroup",
"returns",
"a",
"new",
"WaitGroup",
"using",
"the",
"given",
"context",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/completion/completion.go#L41-L44 |
162,354 | cilium/cilium | pkg/completion/completion.go | Wait | func (wg *WaitGroup) Wait() error {
wg.counterLocker.Lock()
defer wg.counterLocker.Unlock()
var err error
Loop:
for i, comp := range wg.pendingCompletions {
select {
case <-comp.Completed():
err = updateError(err, comp.Err()) // Keep the most severe error value we encounter
continue Loop
case <-wg.ctx.Done():
// Complete the remaining completions (if any) to make sure their completed
// channels are closed.
for _, comp := range wg.pendingCompletions[i:] {
// 'comp' may have already completed on a different error
compErr := comp.Complete(wg.ctx.Err())
err = updateError(err, compErr) // Keep the most severe error value we encounter
}
break Loop
}
}
wg.pendingCompletions = nil
return err
} | go | func (wg *WaitGroup) Wait() error {
wg.counterLocker.Lock()
defer wg.counterLocker.Unlock()
var err error
Loop:
for i, comp := range wg.pendingCompletions {
select {
case <-comp.Completed():
err = updateError(err, comp.Err()) // Keep the most severe error value we encounter
continue Loop
case <-wg.ctx.Done():
// Complete the remaining completions (if any) to make sure their completed
// channels are closed.
for _, comp := range wg.pendingCompletions[i:] {
// 'comp' may have already completed on a different error
compErr := comp.Complete(wg.ctx.Err())
err = updateError(err, compErr) // Keep the most severe error value we encounter
}
break Loop
}
}
wg.pendingCompletions = nil
return err
} | [
"func",
"(",
"wg",
"*",
"WaitGroup",
")",
"Wait",
"(",
")",
"error",
"{",
"wg",
".",
"counterLocker",
".",
"Lock",
"(",
")",
"\n",
"defer",
"wg",
".",
"counterLocker",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"Loop",
":",
"for",
"i",
",",
"comp",
":=",
"range",
"wg",
".",
"pendingCompletions",
"{",
"select",
"{",
"case",
"<-",
"comp",
".",
"Completed",
"(",
")",
":",
"err",
"=",
"updateError",
"(",
"err",
",",
"comp",
".",
"Err",
"(",
")",
")",
"// Keep the most severe error value we encounter",
"\n",
"continue",
"Loop",
"\n",
"case",
"<-",
"wg",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"// Complete the remaining completions (if any) to make sure their completed",
"// channels are closed.",
"for",
"_",
",",
"comp",
":=",
"range",
"wg",
".",
"pendingCompletions",
"[",
"i",
":",
"]",
"{",
"// 'comp' may have already completed on a different error",
"compErr",
":=",
"comp",
".",
"Complete",
"(",
"wg",
".",
"ctx",
".",
"Err",
"(",
")",
")",
"\n",
"err",
"=",
"updateError",
"(",
"err",
",",
"compErr",
")",
"// Keep the most severe error value we encounter",
"\n",
"}",
"\n",
"break",
"Loop",
"\n",
"}",
"\n",
"}",
"\n",
"wg",
".",
"pendingCompletions",
"=",
"nil",
"\n",
"return",
"err",
"\n",
"}"
] | // Wait blocks until all completions added by calling AddCompletion are
// completed, or the context is canceled, whichever happens first.
// Returns the context's error if it is cancelled, nil otherwise.
// No callbacks of the completions in this wait group will be called after
// this returns.
// Returns the error value of one of the completions, if available, or the
// error value of the Context otherwise. | [
"Wait",
"blocks",
"until",
"all",
"completions",
"added",
"by",
"calling",
"AddCompletion",
"are",
"completed",
"or",
"the",
"context",
"is",
"canceled",
"whichever",
"happens",
"first",
".",
"Returns",
"the",
"context",
"s",
"error",
"if",
"it",
"is",
"cancelled",
"nil",
"otherwise",
".",
"No",
"callbacks",
"of",
"the",
"completions",
"in",
"this",
"wait",
"group",
"will",
"be",
"called",
"after",
"this",
"returns",
".",
"Returns",
"the",
"error",
"value",
"of",
"one",
"of",
"the",
"completions",
"if",
"available",
"or",
"the",
"error",
"value",
"of",
"the",
"Context",
"otherwise",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/completion/completion.go#L97-L121 |
162,355 | cilium/cilium | pkg/completion/completion.go | Err | func (c *Completion) Err() error {
c.lock.Lock()
defer c.lock.Unlock()
return c.err
} | go | func (c *Completion) Err() error {
c.lock.Lock()
defer c.lock.Unlock()
return c.err
} | [
"func",
"(",
"c",
"*",
"Completion",
")",
"Err",
"(",
")",
"error",
"{",
"c",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"err",
"\n",
"}"
] | // Err returns a non-nil error if the completion ended in error | [
"Err",
"returns",
"a",
"non",
"-",
"nil",
"error",
"if",
"the",
"completion",
"ended",
"in",
"error"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/completion/completion.go#L144-L148 |
162,356 | cilium/cilium | pkg/completion/completion.go | Complete | func (c *Completion) Complete(err error) error {
c.lock.Lock()
select {
case <-c.completed:
err = c.err // return the error 'c' completed with
default:
c.err = err
if c.callback != nil {
// We must call the callbacks synchronously to guarantee
// that they are actually called before Wait() returns.
c.callback(err)
}
// Cancel the WaitGroup on failure
if err != nil && c.cancel != nil {
c.cancel()
}
close(c.completed)
}
c.lock.Unlock()
return err
} | go | func (c *Completion) Complete(err error) error {
c.lock.Lock()
select {
case <-c.completed:
err = c.err // return the error 'c' completed with
default:
c.err = err
if c.callback != nil {
// We must call the callbacks synchronously to guarantee
// that they are actually called before Wait() returns.
c.callback(err)
}
// Cancel the WaitGroup on failure
if err != nil && c.cancel != nil {
c.cancel()
}
close(c.completed)
}
c.lock.Unlock()
return err
} | [
"func",
"(",
"c",
"*",
"Completion",
")",
"Complete",
"(",
"err",
"error",
")",
"error",
"{",
"c",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"c",
".",
"completed",
":",
"err",
"=",
"c",
".",
"err",
"// return the error 'c' completed with",
"\n",
"default",
":",
"c",
".",
"err",
"=",
"err",
"\n",
"if",
"c",
".",
"callback",
"!=",
"nil",
"{",
"// We must call the callbacks synchronously to guarantee",
"// that they are actually called before Wait() returns.",
"c",
".",
"callback",
"(",
"err",
")",
"\n",
"}",
"\n",
"// Cancel the WaitGroup on failure",
"if",
"err",
"!=",
"nil",
"&&",
"c",
".",
"cancel",
"!=",
"nil",
"{",
"c",
".",
"cancel",
"(",
")",
"\n",
"}",
"\n",
"close",
"(",
"c",
".",
"completed",
")",
"\n",
"}",
"\n",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Complete notifies of the completion of the asynchronous computation.
// Idempotent.
// If the operation completed successfully 'err' is passed as nil.
// Returns the error state the completion completed with, which is
// gnerally different from 'err' if already completed. | [
"Complete",
"notifies",
"of",
"the",
"completion",
"of",
"the",
"asynchronous",
"computation",
".",
"Idempotent",
".",
"If",
"the",
"operation",
"completed",
"successfully",
"err",
"is",
"passed",
"as",
"nil",
".",
"Returns",
"the",
"error",
"state",
"the",
"completion",
"completed",
"with",
"which",
"is",
"gnerally",
"different",
"from",
"err",
"if",
"already",
"completed",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/completion/completion.go#L155-L175 |
162,357 | cilium/cilium | api/v1/server/restapi/policy/get_identity_responses.go | WithPayload | func (o *GetIdentityOK) WithPayload(payload []*models.Identity) *GetIdentityOK {
o.Payload = payload
return o
} | go | func (o *GetIdentityOK) WithPayload(payload []*models.Identity) *GetIdentityOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"Identity",
")",
"*",
"GetIdentityOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get identity o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"identity",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity_responses.go#L38-L41 |
162,358 | cilium/cilium | api/v1/server/restapi/policy/get_identity_responses.go | WithPayload | func (o *GetIdentityUnreachable) WithPayload(payload models.Error) *GetIdentityUnreachable {
o.Payload = payload
return o
} | go | func (o *GetIdentityUnreachable) WithPayload(payload models.Error) *GetIdentityUnreachable {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityUnreachable",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"GetIdentityUnreachable",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get identity unreachable response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"identity",
"unreachable",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity_responses.go#L109-L112 |
162,359 | cilium/cilium | api/v1/server/restapi/policy/get_identity_responses.go | WithPayload | func (o *GetIdentityInvalidStorageFormat) WithPayload(payload models.Error) *GetIdentityInvalidStorageFormat {
o.Payload = payload
return o
} | go | func (o *GetIdentityInvalidStorageFormat) WithPayload(payload models.Error) *GetIdentityInvalidStorageFormat {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetIdentityInvalidStorageFormat",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"GetIdentityInvalidStorageFormat",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get identity invalid storage format response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"identity",
"invalid",
"storage",
"format",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_identity_responses.go#L151-L154 |
162,360 | cilium/cilium | api/v1/models/trace_selector.go | Validate | func (m *TraceSelector) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateFrom(formats); err != nil {
res = append(res, err)
}
if err := m.validateTo(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *TraceSelector) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateFrom(formats); err != nil {
res = append(res, err)
}
if err := m.validateTo(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"TraceSelector",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateFrom",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateTo",
"(",
"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 selector | [
"Validate",
"validates",
"this",
"trace",
"selector"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/trace_selector.go#L31-L46 |
162,361 | cilium/cilium | proxylib/r2d2/r2d2parser.go | ruleParser | func ruleParser(rule *cilium.PortNetworkPolicyRule) []proxylib.L7NetworkPolicyRule {
l7Rules := rule.GetL7Rules()
var rules []proxylib.L7NetworkPolicyRule
if l7Rules == nil {
return rules
}
for _, l7Rule := range l7Rules.GetL7Rules() {
var rr r2d2Rule
for k, v := range l7Rule.Rule {
switch k {
case "cmd":
rr.cmdExact = v
case "file":
if v != "" {
rr.fileRegexCompiled = regexp.MustCompile(v)
}
default:
proxylib.ParseError(fmt.Sprintf("Unsupported key: %s", k), rule)
}
}
if rr.cmdExact != "" &&
rr.cmdExact != "READ" &&
rr.cmdExact != "WRITE" &&
rr.cmdExact != "HALT" &&
rr.cmdExact != "RESET" {
proxylib.ParseError(fmt.Sprintf("Unable to parse L7 r2d2 rule with invalid cmd: '%s'", rr.cmdExact), rule)
}
if (rr.fileRegexCompiled != nil) && !(rr.cmdExact == "" || rr.cmdExact == "READ" || rr.cmdExact == "WRITE") {
proxylib.ParseError(fmt.Sprintf("Unable to parse L7 r2d2 rule, cmd '%s' is not compatible with 'file'", rr.cmdExact), rule)
}
regexStr := ""
if rr.fileRegexCompiled != nil {
regexStr = rr.fileRegexCompiled.String()
}
log.Infof("Parsed rule '%s' '%s'", rr.cmdExact, regexStr)
rules = append(rules, &rr)
}
return rules
} | go | func ruleParser(rule *cilium.PortNetworkPolicyRule) []proxylib.L7NetworkPolicyRule {
l7Rules := rule.GetL7Rules()
var rules []proxylib.L7NetworkPolicyRule
if l7Rules == nil {
return rules
}
for _, l7Rule := range l7Rules.GetL7Rules() {
var rr r2d2Rule
for k, v := range l7Rule.Rule {
switch k {
case "cmd":
rr.cmdExact = v
case "file":
if v != "" {
rr.fileRegexCompiled = regexp.MustCompile(v)
}
default:
proxylib.ParseError(fmt.Sprintf("Unsupported key: %s", k), rule)
}
}
if rr.cmdExact != "" &&
rr.cmdExact != "READ" &&
rr.cmdExact != "WRITE" &&
rr.cmdExact != "HALT" &&
rr.cmdExact != "RESET" {
proxylib.ParseError(fmt.Sprintf("Unable to parse L7 r2d2 rule with invalid cmd: '%s'", rr.cmdExact), rule)
}
if (rr.fileRegexCompiled != nil) && !(rr.cmdExact == "" || rr.cmdExact == "READ" || rr.cmdExact == "WRITE") {
proxylib.ParseError(fmt.Sprintf("Unable to parse L7 r2d2 rule, cmd '%s' is not compatible with 'file'", rr.cmdExact), rule)
}
regexStr := ""
if rr.fileRegexCompiled != nil {
regexStr = rr.fileRegexCompiled.String()
}
log.Infof("Parsed rule '%s' '%s'", rr.cmdExact, regexStr)
rules = append(rules, &rr)
}
return rules
} | [
"func",
"ruleParser",
"(",
"rule",
"*",
"cilium",
".",
"PortNetworkPolicyRule",
")",
"[",
"]",
"proxylib",
".",
"L7NetworkPolicyRule",
"{",
"l7Rules",
":=",
"rule",
".",
"GetL7Rules",
"(",
")",
"\n",
"var",
"rules",
"[",
"]",
"proxylib",
".",
"L7NetworkPolicyRule",
"\n",
"if",
"l7Rules",
"==",
"nil",
"{",
"return",
"rules",
"\n",
"}",
"\n",
"for",
"_",
",",
"l7Rule",
":=",
"range",
"l7Rules",
".",
"GetL7Rules",
"(",
")",
"{",
"var",
"rr",
"r2d2Rule",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"l7Rule",
".",
"Rule",
"{",
"switch",
"k",
"{",
"case",
"\"",
"\"",
":",
"rr",
".",
"cmdExact",
"=",
"v",
"\n",
"case",
"\"",
"\"",
":",
"if",
"v",
"!=",
"\"",
"\"",
"{",
"rr",
".",
"fileRegexCompiled",
"=",
"regexp",
".",
"MustCompile",
"(",
"v",
")",
"\n",
"}",
"\n",
"default",
":",
"proxylib",
".",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
")",
",",
"rule",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"rr",
".",
"cmdExact",
"!=",
"\"",
"\"",
"&&",
"rr",
".",
"cmdExact",
"!=",
"\"",
"\"",
"&&",
"rr",
".",
"cmdExact",
"!=",
"\"",
"\"",
"&&",
"rr",
".",
"cmdExact",
"!=",
"\"",
"\"",
"&&",
"rr",
".",
"cmdExact",
"!=",
"\"",
"\"",
"{",
"proxylib",
".",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rr",
".",
"cmdExact",
")",
",",
"rule",
")",
"\n",
"}",
"\n",
"if",
"(",
"rr",
".",
"fileRegexCompiled",
"!=",
"nil",
")",
"&&",
"!",
"(",
"rr",
".",
"cmdExact",
"==",
"\"",
"\"",
"||",
"rr",
".",
"cmdExact",
"==",
"\"",
"\"",
"||",
"rr",
".",
"cmdExact",
"==",
"\"",
"\"",
")",
"{",
"proxylib",
".",
"ParseError",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rr",
".",
"cmdExact",
")",
",",
"rule",
")",
"\n",
"}",
"\n",
"regexStr",
":=",
"\"",
"\"",
"\n",
"if",
"rr",
".",
"fileRegexCompiled",
"!=",
"nil",
"{",
"regexStr",
"=",
"rr",
".",
"fileRegexCompiled",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rr",
".",
"cmdExact",
",",
"regexStr",
")",
"\n",
"rules",
"=",
"append",
"(",
"rules",
",",
"&",
"rr",
")",
"\n",
"}",
"\n",
"return",
"rules",
"\n",
"}"
] | // ruleParser parses protobuf L7 rules to enforcement objects
// May panic | [
"ruleParser",
"parses",
"protobuf",
"L7",
"rules",
"to",
"enforcement",
"objects",
"May",
"panic"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/proxylib/r2d2/r2d2parser.go#L89-L127 |
162,362 | cilium/cilium | pkg/client/identity.go | IdentityGet | func (c *Client) IdentityGet(id string) (*models.Identity, error) {
params := policy.NewGetIdentityIDParams().WithID(id).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetIdentityID(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) IdentityGet(id string) (*models.Identity, error) {
params := policy.NewGetIdentityIDParams().WithID(id).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetIdentityID(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"IdentityGet",
"(",
"id",
"string",
")",
"(",
"*",
"models",
".",
"Identity",
",",
"error",
")",
"{",
"params",
":=",
"policy",
".",
"NewGetIdentityIDParams",
"(",
")",
".",
"WithID",
"(",
"id",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"Policy",
".",
"GetIdentityID",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"nil",
"\n",
"}"
] | // IdentityGet returns a security identity. | [
"IdentityGet",
"returns",
"a",
"security",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/identity.go#L24-L32 |
162,363 | cilium/cilium | pkg/datapath/linux/utils.go | defineUint32 | func defineUint32(name string, value uint32) string {
return fmt.Sprintf("DEFINE_U32(%s, %#08x);\t/* %d */\n#define %s fetch_u32(%s)\n",
name, value, value, name, name)
} | go | func defineUint32(name string, value uint32) string {
return fmt.Sprintf("DEFINE_U32(%s, %#08x);\t/* %d */\n#define %s fetch_u32(%s)\n",
name, value, value, name, name)
} | [
"func",
"defineUint32",
"(",
"name",
"string",
",",
"value",
"uint32",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\t",
"\\n",
"\\n",
"\"",
",",
"name",
",",
"value",
",",
"value",
",",
"name",
",",
"name",
")",
"\n",
"}"
] | // defineUint32 writes the C definition for an unsigned 32-bit value. | [
"defineUint32",
"writes",
"the",
"C",
"definition",
"for",
"an",
"unsigned",
"32",
"-",
"bit",
"value",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/utils.go#L50-L53 |
162,364 | cilium/cilium | pkg/datapath/linux/utils.go | defineIPv4 | func defineIPv4(name string, addr []byte) string {
if len(addr) != net.IPv4len {
return fmt.Sprintf("/* BUG: bad ip define %s %s */\n", name, goArray2C(addr))
}
nboAddr := byteorder.HostSliceToNetwork(addr, reflect.Uint32).(uint32)
return defineUint32(name, nboAddr)
} | go | func defineIPv4(name string, addr []byte) string {
if len(addr) != net.IPv4len {
return fmt.Sprintf("/* BUG: bad ip define %s %s */\n", name, goArray2C(addr))
}
nboAddr := byteorder.HostSliceToNetwork(addr, reflect.Uint32).(uint32)
return defineUint32(name, nboAddr)
} | [
"func",
"defineIPv4",
"(",
"name",
"string",
",",
"addr",
"[",
"]",
"byte",
")",
"string",
"{",
"if",
"len",
"(",
"addr",
")",
"!=",
"net",
".",
"IPv4len",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
",",
"goArray2C",
"(",
"addr",
")",
")",
"\n",
"}",
"\n",
"nboAddr",
":=",
"byteorder",
".",
"HostSliceToNetwork",
"(",
"addr",
",",
"reflect",
".",
"Uint32",
")",
".",
"(",
"uint32",
")",
"\n",
"return",
"defineUint32",
"(",
"name",
",",
"nboAddr",
")",
"\n",
"}"
] | // defineIPv4 writes the C definition for the given IPv4 address. | [
"defineIPv4",
"writes",
"the",
"C",
"definition",
"for",
"the",
"given",
"IPv4",
"address",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/utils.go#L56-L62 |
162,365 | cilium/cilium | pkg/datapath/linux/utils.go | defineIPv6 | func defineIPv6(name string, addr []byte) string {
if len(addr) != net.IPv6len {
return fmt.Sprintf("/* BUG: bad ip define %s %s */\n", name, goArray2C(addr))
}
return fmt.Sprintf("DEFINE_IPV6(%s, %s);\n", name, goArray2C(addr))
} | go | func defineIPv6(name string, addr []byte) string {
if len(addr) != net.IPv6len {
return fmt.Sprintf("/* BUG: bad ip define %s %s */\n", name, goArray2C(addr))
}
return fmt.Sprintf("DEFINE_IPV6(%s, %s);\n", name, goArray2C(addr))
} | [
"func",
"defineIPv6",
"(",
"name",
"string",
",",
"addr",
"[",
"]",
"byte",
")",
"string",
"{",
"if",
"len",
"(",
"addr",
")",
"!=",
"net",
".",
"IPv6len",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
",",
"goArray2C",
"(",
"addr",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
",",
"goArray2C",
"(",
"addr",
")",
")",
"\n",
"}"
] | // defineIPv6 writes the C definition for the given IPv6 address. | [
"defineIPv6",
"writes",
"the",
"C",
"definition",
"for",
"the",
"given",
"IPv6",
"address",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/utils.go#L65-L70 |
162,366 | cilium/cilium | pkg/datapath/linux/utils.go | defineMAC | func defineMAC(name string, addr []byte) string {
if len(addr) != 6 { /* MAC len */
return fmt.Sprintf("/* BUG: bad mac define %s %s */\n", name, goArray2C(addr))
}
return fmt.Sprintf("DEFINE_MAC(%s, %s);\n#define %s fetch_mac(%s)\n",
name, goArray2C(addr), name, name)
} | go | func defineMAC(name string, addr []byte) string {
if len(addr) != 6 { /* MAC len */
return fmt.Sprintf("/* BUG: bad mac define %s %s */\n", name, goArray2C(addr))
}
return fmt.Sprintf("DEFINE_MAC(%s, %s);\n#define %s fetch_mac(%s)\n",
name, goArray2C(addr), name, name)
} | [
"func",
"defineMAC",
"(",
"name",
"string",
",",
"addr",
"[",
"]",
"byte",
")",
"string",
"{",
"if",
"len",
"(",
"addr",
")",
"!=",
"6",
"{",
"/* MAC len */",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
",",
"goArray2C",
"(",
"addr",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"name",
",",
"goArray2C",
"(",
"addr",
")",
",",
"name",
",",
"name",
")",
"\n",
"}"
] | // defineMAC writes the C definition for the given MAC name and addr. | [
"defineMAC",
"writes",
"the",
"C",
"definition",
"for",
"the",
"given",
"MAC",
"name",
"and",
"addr",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/linux/utils.go#L73-L79 |
162,367 | cilium/cilium | pkg/endpoint/events.go | Handle | func (ev *EndpointRegenerationEvent) Handle(res chan interface{}) {
e := ev.ep
owner := ev.owner
regenContext := ev.regenContext
err := e.RLockAlive()
if err != nil {
e.LogDisconnectedMutexAction(err, "before regeneration")
res <- &EndpointRegenerationResult{
err: err,
}
return
}
e.RUnlock()
// We should only queue the request after we use all the endpoint's
// lock/unlock. Otherwise this can get a deadlock if the endpoint is
// being deleted at the same time. More info PR-1777.
doneFunc, err := owner.QueueEndpointBuild(regenContext.parentContext, uint64(e.ID))
if err != nil {
e.getLogger().WithError(err).Warning("unable to queue endpoint build")
} else if doneFunc != nil {
e.getLogger().Debug("Dequeued endpoint from build queue")
regenContext.DoneFunc = doneFunc
err = ev.ep.regenerate(ev.owner, ev.regenContext)
doneFunc()
e.notifyEndpointRegeneration(owner, err)
} else {
// If another build has been queued for the endpoint, that means that
// that build will be able to take care of all of the work needed to
// regenerate the endpoint at this current point in time; queueing
// another build is a waste of resources.
e.getLogger().Debug("build not queued for endpoint because another build has already been queued")
}
res <- &EndpointRegenerationResult{
err: err,
}
return
} | go | func (ev *EndpointRegenerationEvent) Handle(res chan interface{}) {
e := ev.ep
owner := ev.owner
regenContext := ev.regenContext
err := e.RLockAlive()
if err != nil {
e.LogDisconnectedMutexAction(err, "before regeneration")
res <- &EndpointRegenerationResult{
err: err,
}
return
}
e.RUnlock()
// We should only queue the request after we use all the endpoint's
// lock/unlock. Otherwise this can get a deadlock if the endpoint is
// being deleted at the same time. More info PR-1777.
doneFunc, err := owner.QueueEndpointBuild(regenContext.parentContext, uint64(e.ID))
if err != nil {
e.getLogger().WithError(err).Warning("unable to queue endpoint build")
} else if doneFunc != nil {
e.getLogger().Debug("Dequeued endpoint from build queue")
regenContext.DoneFunc = doneFunc
err = ev.ep.regenerate(ev.owner, ev.regenContext)
doneFunc()
e.notifyEndpointRegeneration(owner, err)
} else {
// If another build has been queued for the endpoint, that means that
// that build will be able to take care of all of the work needed to
// regenerate the endpoint at this current point in time; queueing
// another build is a waste of resources.
e.getLogger().Debug("build not queued for endpoint because another build has already been queued")
}
res <- &EndpointRegenerationResult{
err: err,
}
return
} | [
"func",
"(",
"ev",
"*",
"EndpointRegenerationEvent",
")",
"Handle",
"(",
"res",
"chan",
"interface",
"{",
"}",
")",
"{",
"e",
":=",
"ev",
".",
"ep",
"\n",
"owner",
":=",
"ev",
".",
"owner",
"\n",
"regenContext",
":=",
"ev",
".",
"regenContext",
"\n\n",
"err",
":=",
"e",
".",
"RLockAlive",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"e",
".",
"LogDisconnectedMutexAction",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"res",
"<-",
"&",
"EndpointRegenerationResult",
"{",
"err",
":",
"err",
",",
"}",
"\n\n",
"return",
"\n",
"}",
"\n",
"e",
".",
"RUnlock",
"(",
")",
"\n\n",
"// We should only queue the request after we use all the endpoint's",
"// lock/unlock. Otherwise this can get a deadlock if the endpoint is",
"// being deleted at the same time. More info PR-1777.",
"doneFunc",
",",
"err",
":=",
"owner",
".",
"QueueEndpointBuild",
"(",
"regenContext",
".",
"parentContext",
",",
"uint64",
"(",
"e",
".",
"ID",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"e",
".",
"getLogger",
"(",
")",
".",
"WithError",
"(",
"err",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"doneFunc",
"!=",
"nil",
"{",
"e",
".",
"getLogger",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"regenContext",
".",
"DoneFunc",
"=",
"doneFunc",
"\n\n",
"err",
"=",
"ev",
".",
"ep",
".",
"regenerate",
"(",
"ev",
".",
"owner",
",",
"ev",
".",
"regenContext",
")",
"\n\n",
"doneFunc",
"(",
")",
"\n",
"e",
".",
"notifyEndpointRegeneration",
"(",
"owner",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"// If another build has been queued for the endpoint, that means that",
"// that build will be able to take care of all of the work needed to",
"// regenerate the endpoint at this current point in time; queueing",
"// another build is a waste of resources.",
"e",
".",
"getLogger",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"res",
"<-",
"&",
"EndpointRegenerationResult",
"{",
"err",
":",
"err",
",",
"}",
"\n",
"return",
"\n",
"}"
] | // Handle handles the regeneration event for the endpoint. | [
"Handle",
"handles",
"the",
"regeneration",
"event",
"for",
"the",
"endpoint",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/events.go#L29-L72 |
162,368 | cilium/cilium | pkg/endpoint/events.go | Handle | func (ev *EndpointRevisionBumpEvent) Handle(res chan interface{}) {
// TODO: if the endpoint is not in a 'ready' state that means that
// we cannot set the policy revision, as something else has
// changed endpoint state which necessitates regeneration,
// *or* the endpoint is in a not-ready state (i.e., a prior
// regeneration failed, so there is no way that we can
// realize the policy revision yet. Should this be signaled
// to the routine waiting for the result of this event?
ev.ep.SetPolicyRevision(ev.Rev)
res <- struct{}{}
} | go | func (ev *EndpointRevisionBumpEvent) Handle(res chan interface{}) {
// TODO: if the endpoint is not in a 'ready' state that means that
// we cannot set the policy revision, as something else has
// changed endpoint state which necessitates regeneration,
// *or* the endpoint is in a not-ready state (i.e., a prior
// regeneration failed, so there is no way that we can
// realize the policy revision yet. Should this be signaled
// to the routine waiting for the result of this event?
ev.ep.SetPolicyRevision(ev.Rev)
res <- struct{}{}
} | [
"func",
"(",
"ev",
"*",
"EndpointRevisionBumpEvent",
")",
"Handle",
"(",
"res",
"chan",
"interface",
"{",
"}",
")",
"{",
"// TODO: if the endpoint is not in a 'ready' state that means that",
"// we cannot set the policy revision, as something else has",
"// changed endpoint state which necessitates regeneration,",
"// *or* the endpoint is in a not-ready state (i.e., a prior",
"// regeneration failed, so there is no way that we can",
"// realize the policy revision yet. Should this be signaled",
"// to the routine waiting for the result of this event?",
"ev",
".",
"ep",
".",
"SetPolicyRevision",
"(",
"ev",
".",
"Rev",
")",
"\n",
"res",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}"
] | // Handle handles the revision bump event for the Endpoint. | [
"Handle",
"handles",
"the",
"revision",
"bump",
"event",
"for",
"the",
"Endpoint",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/events.go#L87-L97 |
162,369 | cilium/cilium | pkg/endpoint/events.go | PolicyRevisionBumpEvent | func (e *Endpoint) PolicyRevisionBumpEvent(rev uint64) {
epBumpEvent := eventqueue.NewEvent(&EndpointRevisionBumpEvent{Rev: rev, ep: e})
// Don't care about policy revision event results - it is best effort.
_ = e.EventQueue.Enqueue(epBumpEvent)
} | go | func (e *Endpoint) PolicyRevisionBumpEvent(rev uint64) {
epBumpEvent := eventqueue.NewEvent(&EndpointRevisionBumpEvent{Rev: rev, ep: e})
// Don't care about policy revision event results - it is best effort.
_ = e.EventQueue.Enqueue(epBumpEvent)
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"PolicyRevisionBumpEvent",
"(",
"rev",
"uint64",
")",
"{",
"epBumpEvent",
":=",
"eventqueue",
".",
"NewEvent",
"(",
"&",
"EndpointRevisionBumpEvent",
"{",
"Rev",
":",
"rev",
",",
"ep",
":",
"e",
"}",
")",
"\n",
"// Don't care about policy revision event results - it is best effort.",
"_",
"=",
"e",
".",
"EventQueue",
".",
"Enqueue",
"(",
"epBumpEvent",
")",
"\n",
"}"
] | // PolicyRevisionBumpEvent queues an event for the given endpoint to set its
// realized policy revision to rev. This may block depending on if events have
// been queued up for the given endpoint. It blocks until the event has
// succeeded, or if the event has been cancelled. | [
"PolicyRevisionBumpEvent",
"queues",
"an",
"event",
"for",
"the",
"given",
"endpoint",
"to",
"set",
"its",
"realized",
"policy",
"revision",
"to",
"rev",
".",
"This",
"may",
"block",
"depending",
"on",
"if",
"events",
"have",
"been",
"queued",
"up",
"for",
"the",
"given",
"endpoint",
".",
"It",
"blocks",
"until",
"the",
"event",
"has",
"succeeded",
"or",
"if",
"the",
"event",
"has",
"been",
"cancelled",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/events.go#L103-L107 |
162,370 | cilium/cilium | pkg/revert/revert.go | Push | func (s *RevertStack) Push(revertFunc RevertFunc) {
if revertFunc != nil {
s.revertFuncs = append(s.revertFuncs, revertFunc)
}
} | go | func (s *RevertStack) Push(revertFunc RevertFunc) {
if revertFunc != nil {
s.revertFuncs = append(s.revertFuncs, revertFunc)
}
} | [
"func",
"(",
"s",
"*",
"RevertStack",
")",
"Push",
"(",
"revertFunc",
"RevertFunc",
")",
"{",
"if",
"revertFunc",
"!=",
"nil",
"{",
"s",
".",
"revertFuncs",
"=",
"append",
"(",
"s",
".",
"revertFuncs",
",",
"revertFunc",
")",
"\n",
"}",
"\n",
"}"
] | // Push pushes the given RevertFunc on top of this stack. If the function is
// nil, it is ignored. | [
"Push",
"pushes",
"the",
"given",
"RevertFunc",
"on",
"top",
"of",
"this",
"stack",
".",
"If",
"the",
"function",
"is",
"nil",
"it",
"is",
"ignored",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/revert/revert.go#L34-L38 |
162,371 | cilium/cilium | pkg/revert/revert.go | Revert | func (s *RevertStack) Revert() error {
for i := len(s.revertFuncs) - 1; i >= 0; i-- {
if err := s.revertFuncs[i](); err != nil {
return fmt.Errorf("failed to execute revert function; skipping %d revert functions: %s", i, err)
}
}
return nil
} | go | func (s *RevertStack) Revert() error {
for i := len(s.revertFuncs) - 1; i >= 0; i-- {
if err := s.revertFuncs[i](); err != nil {
return fmt.Errorf("failed to execute revert function; skipping %d revert functions: %s", i, err)
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"RevertStack",
")",
"Revert",
"(",
")",
"error",
"{",
"for",
"i",
":=",
"len",
"(",
"s",
".",
"revertFuncs",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"if",
"err",
":=",
"s",
".",
"revertFuncs",
"[",
"i",
"]",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Revert executes all the RevertFuncs in the given stack in the reverse order
// they were pushed. | [
"Revert",
"executes",
"all",
"the",
"RevertFuncs",
"in",
"the",
"given",
"stack",
"in",
"the",
"reverse",
"order",
"they",
"were",
"pushed",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/revert/revert.go#L42-L49 |
162,372 | cilium/cilium | api/v1/models/l4_policy.go | Validate | func (m *L4Policy) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateEgress(formats); err != nil {
res = append(res, err)
}
if err := m.validateIngress(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *L4Policy) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateEgress(formats); err != nil {
res = append(res, err)
}
if err := m.validateIngress(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"L4Policy",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateEgress",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateIngress",
"(",
"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 l4 policy | [
"Validate",
"validates",
"this",
"l4",
"policy"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/l4_policy.go#L29-L44 |
162,373 | cilium/cilium | api/v1/server/restapi/daemon/get_map_responses.go | WithPayload | func (o *GetMapOK) WithPayload(payload *models.BPFMapList) *GetMapOK {
o.Payload = payload
return o
} | go | func (o *GetMapOK) WithPayload(payload *models.BPFMapList) *GetMapOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetMapOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"BPFMapList",
")",
"*",
"GetMapOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get map o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"map",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/daemon/get_map_responses.go#L38-L41 |
162,374 | cilium/cilium | api/v1/server/restapi/service/get_service_id_responses.go | WithPayload | func (o *GetServiceIDOK) WithPayload(payload *models.Service) *GetServiceIDOK {
o.Payload = payload
return o
} | go | func (o *GetServiceIDOK) WithPayload(payload *models.Service) *GetServiceIDOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetServiceIDOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"Service",
")",
"*",
"GetServiceIDOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get service Id o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"service",
"Id",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/service/get_service_id_responses.go#L38-L41 |
162,375 | cilium/cilium | pkg/client/policy.go | PolicyPut | func (c *Client) PolicyPut(policyJSON string) (*models.Policy, error) {
params := policy.NewPutPolicyParams().WithPolicy(policyJSON).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.PutPolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) PolicyPut(policyJSON string) (*models.Policy, error) {
params := policy.NewPutPolicyParams().WithPolicy(policyJSON).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.PutPolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PolicyPut",
"(",
"policyJSON",
"string",
")",
"(",
"*",
"models",
".",
"Policy",
",",
"error",
")",
"{",
"params",
":=",
"policy",
".",
"NewPutPolicyParams",
"(",
")",
".",
"WithPolicy",
"(",
"policyJSON",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"Policy",
".",
"PutPolicy",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"nil",
"\n",
"}"
] | // PolicyPut inserts the `policyJSON` | [
"PolicyPut",
"inserts",
"the",
"policyJSON"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/policy.go#L24-L31 |
162,376 | cilium/cilium | pkg/client/policy.go | PolicyGet | func (c *Client) PolicyGet(labels []string) (*models.Policy, error) {
params := policy.NewGetPolicyParams().WithLabels(labels).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetPolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) PolicyGet(labels []string) (*models.Policy, error) {
params := policy.NewGetPolicyParams().WithLabels(labels).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetPolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PolicyGet",
"(",
"labels",
"[",
"]",
"string",
")",
"(",
"*",
"models",
".",
"Policy",
",",
"error",
")",
"{",
"params",
":=",
"policy",
".",
"NewGetPolicyParams",
"(",
")",
".",
"WithLabels",
"(",
"labels",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"Policy",
".",
"GetPolicy",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"nil",
"\n",
"}"
] | // PolicyGet returns policy rules | [
"PolicyGet",
"returns",
"policy",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/policy.go#L34-L41 |
162,377 | cilium/cilium | pkg/client/policy.go | PolicyDelete | func (c *Client) PolicyDelete(labels []string) (*models.Policy, error) {
params := policy.NewDeletePolicyParams().WithLabels(labels).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.DeletePolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, Hint(err)
} | go | func (c *Client) PolicyDelete(labels []string) (*models.Policy, error) {
params := policy.NewDeletePolicyParams().WithLabels(labels).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.DeletePolicy(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, Hint(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PolicyDelete",
"(",
"labels",
"[",
"]",
"string",
")",
"(",
"*",
"models",
".",
"Policy",
",",
"error",
")",
"{",
"params",
":=",
"policy",
".",
"NewDeletePolicyParams",
"(",
")",
".",
"WithLabels",
"(",
"labels",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"Policy",
".",
"DeletePolicy",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"Hint",
"(",
"err",
")",
"\n",
"}"
] | // PolicyDelete deletes policy rules | [
"PolicyDelete",
"deletes",
"policy",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/policy.go#L44-L51 |
162,378 | cilium/cilium | pkg/client/policy.go | PolicyResolveGet | func (c *Client) PolicyResolveGet(traceSelector *models.TraceSelector) (*models.PolicyTraceResult, error) {
params := policy.NewGetPolicyResolveParams().WithTraceSelector(traceSelector).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetPolicyResolve(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | go | func (c *Client) PolicyResolveGet(traceSelector *models.TraceSelector) (*models.PolicyTraceResult, error) {
params := policy.NewGetPolicyResolveParams().WithTraceSelector(traceSelector).WithTimeout(api.ClientTimeout)
resp, err := c.Policy.GetPolicyResolve(params)
if err != nil {
return nil, Hint(err)
}
return resp.Payload, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PolicyResolveGet",
"(",
"traceSelector",
"*",
"models",
".",
"TraceSelector",
")",
"(",
"*",
"models",
".",
"PolicyTraceResult",
",",
"error",
")",
"{",
"params",
":=",
"policy",
".",
"NewGetPolicyResolveParams",
"(",
")",
".",
"WithTraceSelector",
"(",
"traceSelector",
")",
".",
"WithTimeout",
"(",
"api",
".",
"ClientTimeout",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"Policy",
".",
"GetPolicyResolve",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"Hint",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Payload",
",",
"nil",
"\n",
"}"
] | // PolicyResolveGet resolves policy for a Trace Selector with source and destination identity. | [
"PolicyResolveGet",
"resolves",
"policy",
"for",
"a",
"Trace",
"Selector",
"with",
"source",
"and",
"destination",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/client/policy.go#L54-L61 |
162,379 | cilium/cilium | pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go | List | func (s *ciliumNetworkPolicyLister) List(selector labels.Selector) (ret []*v2.CiliumNetworkPolicy, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v2.CiliumNetworkPolicy))
})
return ret, err
} | go | func (s *ciliumNetworkPolicyLister) List(selector labels.Selector) (ret []*v2.CiliumNetworkPolicy, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v2.CiliumNetworkPolicy))
})
return ret, err
} | [
"func",
"(",
"s",
"*",
"ciliumNetworkPolicyLister",
")",
"List",
"(",
"selector",
"labels",
".",
"Selector",
")",
"(",
"ret",
"[",
"]",
"*",
"v2",
".",
"CiliumNetworkPolicy",
",",
"err",
"error",
")",
"{",
"err",
"=",
"cache",
".",
"ListAll",
"(",
"s",
".",
"indexer",
",",
"selector",
",",
"func",
"(",
"m",
"interface",
"{",
"}",
")",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"m",
".",
"(",
"*",
"v2",
".",
"CiliumNetworkPolicy",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"ret",
",",
"err",
"\n",
"}"
] | // List lists all CiliumNetworkPolicies in the indexer. | [
"List",
"lists",
"all",
"CiliumNetworkPolicies",
"in",
"the",
"indexer",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go#L46-L51 |
162,380 | cilium/cilium | pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go | CiliumNetworkPolicies | func (s *ciliumNetworkPolicyLister) CiliumNetworkPolicies(namespace string) CiliumNetworkPolicyNamespaceLister {
return ciliumNetworkPolicyNamespaceLister{indexer: s.indexer, namespace: namespace}
} | go | func (s *ciliumNetworkPolicyLister) CiliumNetworkPolicies(namespace string) CiliumNetworkPolicyNamespaceLister {
return ciliumNetworkPolicyNamespaceLister{indexer: s.indexer, namespace: namespace}
} | [
"func",
"(",
"s",
"*",
"ciliumNetworkPolicyLister",
")",
"CiliumNetworkPolicies",
"(",
"namespace",
"string",
")",
"CiliumNetworkPolicyNamespaceLister",
"{",
"return",
"ciliumNetworkPolicyNamespaceLister",
"{",
"indexer",
":",
"s",
".",
"indexer",
",",
"namespace",
":",
"namespace",
"}",
"\n",
"}"
] | // CiliumNetworkPolicies returns an object that can list and get CiliumNetworkPolicies. | [
"CiliumNetworkPolicies",
"returns",
"an",
"object",
"that",
"can",
"list",
"and",
"get",
"CiliumNetworkPolicies",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go#L54-L56 |
162,381 | cilium/cilium | pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go | List | func (s ciliumNetworkPolicyNamespaceLister) List(selector labels.Selector) (ret []*v2.CiliumNetworkPolicy, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v2.CiliumNetworkPolicy))
})
return ret, err
} | go | func (s ciliumNetworkPolicyNamespaceLister) List(selector labels.Selector) (ret []*v2.CiliumNetworkPolicy, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v2.CiliumNetworkPolicy))
})
return ret, err
} | [
"func",
"(",
"s",
"ciliumNetworkPolicyNamespaceLister",
")",
"List",
"(",
"selector",
"labels",
".",
"Selector",
")",
"(",
"ret",
"[",
"]",
"*",
"v2",
".",
"CiliumNetworkPolicy",
",",
"err",
"error",
")",
"{",
"err",
"=",
"cache",
".",
"ListAllByNamespace",
"(",
"s",
".",
"indexer",
",",
"s",
".",
"namespace",
",",
"selector",
",",
"func",
"(",
"m",
"interface",
"{",
"}",
")",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"m",
".",
"(",
"*",
"v2",
".",
"CiliumNetworkPolicy",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"ret",
",",
"err",
"\n",
"}"
] | // List lists all CiliumNetworkPolicies in the indexer for a given namespace. | [
"List",
"lists",
"all",
"CiliumNetworkPolicies",
"in",
"the",
"indexer",
"for",
"a",
"given",
"namespace",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/listers/cilium.io/v2/ciliumnetworkpolicy.go#L75-L80 |
162,382 | cilium/cilium | cilium/cmd/helpers.go | expandNestedJSON | func expandNestedJSON(result bytes.Buffer) (bytes.Buffer, error) {
reStringWithJSON := regexp.MustCompile(`"[^"\\{]*{.*[^\\]"`)
reJSON := regexp.MustCompile(`{.*}`)
for {
var (
loc []int
indent string
)
// Search for nested JSON; if we don't find any, then break.
resBytes := result.Bytes()
if loc = reStringWithJSON.FindIndex(resBytes); loc == nil {
break
}
// Determine the current indentation
for i := 0; i < loc[0]-1; i++ {
idx := loc[0] - i - 1
if resBytes[idx] != ' ' {
break
}
indent = fmt.Sprintf("\t%s\t", indent)
}
stringStart := loc[0]
stringEnd := loc[1]
// Unquote the string with the nested json.
quotedBytes := resBytes[stringStart:stringEnd]
unquoted, err := strconv.Unquote(string(quotedBytes))
if err != nil {
return bytes.Buffer{}, fmt.Errorf("Failed to Unquote string: %s\n%s", err.Error(), string(quotedBytes))
}
// Find the JSON within the quoted string.
nestedStart := 0
nestedEnd := 0
if locs := reJSON.FindAllStringIndex(unquoted, -1); locs != nil {
// The last match is the longest one.
last := len(locs) - 1
nestedStart = locs[last][0]
nestedEnd = locs[last][1]
} else if reJSON.Match(quotedBytes) {
// The entire string is JSON
nestedEnd = len(unquoted)
}
// Decode the nested JSON
decoded := ""
if nestedEnd != 0 {
m := make(map[string]interface{})
nested := bytes.NewBufferString(unquoted[nestedStart:nestedEnd])
if err := json.NewDecoder(nested).Decode(&m); err != nil {
return bytes.Buffer{}, fmt.Errorf("Failed to decode nested JSON: %s", err.Error())
}
decodedBytes, err := json.MarshalIndent(m, indent, " ")
if err != nil {
return bytes.Buffer{}, fmt.Errorf("Cannot marshal nested JSON: %s", err.Error())
}
decoded = string(decodedBytes)
}
// Serialize
nextResult := bytes.Buffer{}
nextResult.Write(resBytes[0:stringStart])
nextResult.WriteString(string(unquoted[:nestedStart]))
nextResult.WriteString(string(decoded))
nextResult.WriteString(string(unquoted[nestedEnd:]))
nextResult.Write(resBytes[stringEnd:])
result = nextResult
}
return result, nil
} | go | func expandNestedJSON(result bytes.Buffer) (bytes.Buffer, error) {
reStringWithJSON := regexp.MustCompile(`"[^"\\{]*{.*[^\\]"`)
reJSON := regexp.MustCompile(`{.*}`)
for {
var (
loc []int
indent string
)
// Search for nested JSON; if we don't find any, then break.
resBytes := result.Bytes()
if loc = reStringWithJSON.FindIndex(resBytes); loc == nil {
break
}
// Determine the current indentation
for i := 0; i < loc[0]-1; i++ {
idx := loc[0] - i - 1
if resBytes[idx] != ' ' {
break
}
indent = fmt.Sprintf("\t%s\t", indent)
}
stringStart := loc[0]
stringEnd := loc[1]
// Unquote the string with the nested json.
quotedBytes := resBytes[stringStart:stringEnd]
unquoted, err := strconv.Unquote(string(quotedBytes))
if err != nil {
return bytes.Buffer{}, fmt.Errorf("Failed to Unquote string: %s\n%s", err.Error(), string(quotedBytes))
}
// Find the JSON within the quoted string.
nestedStart := 0
nestedEnd := 0
if locs := reJSON.FindAllStringIndex(unquoted, -1); locs != nil {
// The last match is the longest one.
last := len(locs) - 1
nestedStart = locs[last][0]
nestedEnd = locs[last][1]
} else if reJSON.Match(quotedBytes) {
// The entire string is JSON
nestedEnd = len(unquoted)
}
// Decode the nested JSON
decoded := ""
if nestedEnd != 0 {
m := make(map[string]interface{})
nested := bytes.NewBufferString(unquoted[nestedStart:nestedEnd])
if err := json.NewDecoder(nested).Decode(&m); err != nil {
return bytes.Buffer{}, fmt.Errorf("Failed to decode nested JSON: %s", err.Error())
}
decodedBytes, err := json.MarshalIndent(m, indent, " ")
if err != nil {
return bytes.Buffer{}, fmt.Errorf("Cannot marshal nested JSON: %s", err.Error())
}
decoded = string(decodedBytes)
}
// Serialize
nextResult := bytes.Buffer{}
nextResult.Write(resBytes[0:stringStart])
nextResult.WriteString(string(unquoted[:nestedStart]))
nextResult.WriteString(string(decoded))
nextResult.WriteString(string(unquoted[nestedEnd:]))
nextResult.Write(resBytes[stringEnd:])
result = nextResult
}
return result, nil
} | [
"func",
"expandNestedJSON",
"(",
"result",
"bytes",
".",
"Buffer",
")",
"(",
"bytes",
".",
"Buffer",
",",
"error",
")",
"{",
"reStringWithJSON",
":=",
"regexp",
".",
"MustCompile",
"(",
"`\"[^\"\\\\{]*{.*[^\\\\]\"`",
")",
"\n",
"reJSON",
":=",
"regexp",
".",
"MustCompile",
"(",
"`{.*}`",
")",
"\n",
"for",
"{",
"var",
"(",
"loc",
"[",
"]",
"int",
"\n",
"indent",
"string",
"\n",
")",
"\n\n",
"// Search for nested JSON; if we don't find any, then break.",
"resBytes",
":=",
"result",
".",
"Bytes",
"(",
")",
"\n",
"if",
"loc",
"=",
"reStringWithJSON",
".",
"FindIndex",
"(",
"resBytes",
")",
";",
"loc",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"// Determine the current indentation",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"loc",
"[",
"0",
"]",
"-",
"1",
";",
"i",
"++",
"{",
"idx",
":=",
"loc",
"[",
"0",
"]",
"-",
"i",
"-",
"1",
"\n",
"if",
"resBytes",
"[",
"idx",
"]",
"!=",
"' '",
"{",
"break",
"\n",
"}",
"\n",
"indent",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\t",
"\\t",
"\"",
",",
"indent",
")",
"\n",
"}",
"\n\n",
"stringStart",
":=",
"loc",
"[",
"0",
"]",
"\n",
"stringEnd",
":=",
"loc",
"[",
"1",
"]",
"\n\n",
"// Unquote the string with the nested json.",
"quotedBytes",
":=",
"resBytes",
"[",
"stringStart",
":",
"stringEnd",
"]",
"\n",
"unquoted",
",",
"err",
":=",
"strconv",
".",
"Unquote",
"(",
"string",
"(",
"quotedBytes",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
".",
"Error",
"(",
")",
",",
"string",
"(",
"quotedBytes",
")",
")",
"\n",
"}",
"\n\n",
"// Find the JSON within the quoted string.",
"nestedStart",
":=",
"0",
"\n",
"nestedEnd",
":=",
"0",
"\n",
"if",
"locs",
":=",
"reJSON",
".",
"FindAllStringIndex",
"(",
"unquoted",
",",
"-",
"1",
")",
";",
"locs",
"!=",
"nil",
"{",
"// The last match is the longest one.",
"last",
":=",
"len",
"(",
"locs",
")",
"-",
"1",
"\n",
"nestedStart",
"=",
"locs",
"[",
"last",
"]",
"[",
"0",
"]",
"\n",
"nestedEnd",
"=",
"locs",
"[",
"last",
"]",
"[",
"1",
"]",
"\n",
"}",
"else",
"if",
"reJSON",
".",
"Match",
"(",
"quotedBytes",
")",
"{",
"// The entire string is JSON",
"nestedEnd",
"=",
"len",
"(",
"unquoted",
")",
"\n",
"}",
"\n\n",
"// Decode the nested JSON",
"decoded",
":=",
"\"",
"\"",
"\n",
"if",
"nestedEnd",
"!=",
"0",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"nested",
":=",
"bytes",
".",
"NewBufferString",
"(",
"unquoted",
"[",
"nestedStart",
":",
"nestedEnd",
"]",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"nested",
")",
".",
"Decode",
"(",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"decodedBytes",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"m",
",",
"indent",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"decoded",
"=",
"string",
"(",
"decodedBytes",
")",
"\n",
"}",
"\n\n",
"// Serialize",
"nextResult",
":=",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"nextResult",
".",
"Write",
"(",
"resBytes",
"[",
"0",
":",
"stringStart",
"]",
")",
"\n",
"nextResult",
".",
"WriteString",
"(",
"string",
"(",
"unquoted",
"[",
":",
"nestedStart",
"]",
")",
")",
"\n",
"nextResult",
".",
"WriteString",
"(",
"string",
"(",
"decoded",
")",
")",
"\n",
"nextResult",
".",
"WriteString",
"(",
"string",
"(",
"unquoted",
"[",
"nestedEnd",
":",
"]",
")",
")",
"\n",
"nextResult",
".",
"Write",
"(",
"resBytes",
"[",
"stringEnd",
":",
"]",
")",
"\n",
"result",
"=",
"nextResult",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // Search 'result' for strings with escaped JSON inside, and expand the JSON. | [
"Search",
"result",
"for",
"strings",
"with",
"escaped",
"JSON",
"inside",
"and",
"expand",
"the",
"JSON",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium/cmd/helpers.go#L122-L195 |
162,383 | cilium/cilium | cilium/cmd/helpers.go | parseTrafficString | func parseTrafficString(td string) (trafficdirection.TrafficDirection, error) {
lowered := strings.ToLower(td)
switch lowered {
case "ingress":
return trafficdirection.Ingress, nil
case "egress":
return trafficdirection.Egress, nil
default:
return trafficdirection.Invalid, fmt.Errorf("invalid direction %q provided", td)
}
} | go | func parseTrafficString(td string) (trafficdirection.TrafficDirection, error) {
lowered := strings.ToLower(td)
switch lowered {
case "ingress":
return trafficdirection.Ingress, nil
case "egress":
return trafficdirection.Egress, nil
default:
return trafficdirection.Invalid, fmt.Errorf("invalid direction %q provided", td)
}
} | [
"func",
"parseTrafficString",
"(",
"td",
"string",
")",
"(",
"trafficdirection",
".",
"TrafficDirection",
",",
"error",
")",
"{",
"lowered",
":=",
"strings",
".",
"ToLower",
"(",
"td",
")",
"\n\n",
"switch",
"lowered",
"{",
"case",
"\"",
"\"",
":",
"return",
"trafficdirection",
".",
"Ingress",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"trafficdirection",
".",
"Egress",
",",
"nil",
"\n",
"default",
":",
"return",
"trafficdirection",
".",
"Invalid",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"td",
")",
"\n",
"}",
"\n\n",
"}"
] | // parseTrafficString converts the provided string to its corresponding
// TrafficDirection. If the string does not correspond to a valid TrafficDirection
// type, returns Invalid and a corresponding error. | [
"parseTrafficString",
"converts",
"the",
"provided",
"string",
"to",
"its",
"corresponding",
"TrafficDirection",
".",
"If",
"the",
"string",
"does",
"not",
"correspond",
"to",
"a",
"valid",
"TrafficDirection",
"type",
"returns",
"Invalid",
"and",
"a",
"corresponding",
"error",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium/cmd/helpers.go#L221-L233 |
162,384 | cilium/cilium | cilium/cmd/helpers.go | updatePolicyKey | func updatePolicyKey(pa *PolicyUpdateArgs, add bool) {
// The map needs not to be transparently initialized here even if
// it's not present for some reason. Triggering map recreation with
// OpenOrCreate when some map attribute had changed would be much worse.
policyMap, err := policymap.Open(pa.path)
if err != nil {
Fatalf("Cannot open policymap %q : %s", pa.path, err)
}
for _, proto := range pa.protocols {
u8p := u8proto.U8proto(proto)
entry := fmt.Sprintf("%d %d/%s", pa.label, pa.port, u8p.String())
if add {
var proxyPort uint16
if err := policyMap.Allow(pa.label, pa.port, u8p, pa.trafficDirection, proxyPort); err != nil {
Fatalf("Cannot add policy key '%s': %s\n", entry, err)
}
} else {
if err := policyMap.Delete(pa.label, pa.port, u8p, pa.trafficDirection); err != nil {
Fatalf("Cannot delete policy key '%s': %s\n", entry, err)
}
}
}
} | go | func updatePolicyKey(pa *PolicyUpdateArgs, add bool) {
// The map needs not to be transparently initialized here even if
// it's not present for some reason. Triggering map recreation with
// OpenOrCreate when some map attribute had changed would be much worse.
policyMap, err := policymap.Open(pa.path)
if err != nil {
Fatalf("Cannot open policymap %q : %s", pa.path, err)
}
for _, proto := range pa.protocols {
u8p := u8proto.U8proto(proto)
entry := fmt.Sprintf("%d %d/%s", pa.label, pa.port, u8p.String())
if add {
var proxyPort uint16
if err := policyMap.Allow(pa.label, pa.port, u8p, pa.trafficDirection, proxyPort); err != nil {
Fatalf("Cannot add policy key '%s': %s\n", entry, err)
}
} else {
if err := policyMap.Delete(pa.label, pa.port, u8p, pa.trafficDirection); err != nil {
Fatalf("Cannot delete policy key '%s': %s\n", entry, err)
}
}
}
} | [
"func",
"updatePolicyKey",
"(",
"pa",
"*",
"PolicyUpdateArgs",
",",
"add",
"bool",
")",
"{",
"// The map needs not to be transparently initialized here even if",
"// it's not present for some reason. Triggering map recreation with",
"// OpenOrCreate when some map attribute had changed would be much worse.",
"policyMap",
",",
"err",
":=",
"policymap",
".",
"Open",
"(",
"pa",
".",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Fatalf",
"(",
"\"",
"\"",
",",
"pa",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"proto",
":=",
"range",
"pa",
".",
"protocols",
"{",
"u8p",
":=",
"u8proto",
".",
"U8proto",
"(",
"proto",
")",
"\n",
"entry",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pa",
".",
"label",
",",
"pa",
".",
"port",
",",
"u8p",
".",
"String",
"(",
")",
")",
"\n",
"if",
"add",
"{",
"var",
"proxyPort",
"uint16",
"\n",
"if",
"err",
":=",
"policyMap",
".",
"Allow",
"(",
"pa",
".",
"label",
",",
"pa",
".",
"port",
",",
"u8p",
",",
"pa",
".",
"trafficDirection",
",",
"proxyPort",
")",
";",
"err",
"!=",
"nil",
"{",
"Fatalf",
"(",
"\"",
"\\n",
"\"",
",",
"entry",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"policyMap",
".",
"Delete",
"(",
"pa",
".",
"label",
",",
"pa",
".",
"port",
",",
"u8p",
",",
"pa",
".",
"trafficDirection",
")",
";",
"err",
"!=",
"nil",
"{",
"Fatalf",
"(",
"\"",
"\\n",
"\"",
",",
"entry",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // updatePolicyKey updates an entry in the PolicyMap for the provided
// PolicyUpdateArgs argument.
// Adds the entry to the PolicyMap if add is true, otherwise the entry is
// deleted. | [
"updatePolicyKey",
"updates",
"an",
"entry",
"in",
"the",
"PolicyMap",
"for",
"the",
"provided",
"PolicyUpdateArgs",
"argument",
".",
"Adds",
"the",
"entry",
"to",
"the",
"PolicyMap",
"if",
"add",
"is",
"true",
"otherwise",
"the",
"entry",
"is",
"deleted",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium/cmd/helpers.go#L327-L350 |
162,385 | cilium/cilium | cilium/cmd/helpers.go | dumpConfig | func dumpConfig(Opts map[string]string) {
opts := []string{}
for k := range Opts {
opts = append(opts, k)
}
sort.Strings(opts)
for _, k := range opts {
// XXX: Reuse the format function from *option.Library
value = Opts[k]
if enabled, err := option.NormalizeBool(value); err != nil {
// If it cannot be parsed as a bool, just format the value.
fmt.Printf("%-24s %s\n", k, color.Green(value))
} else if enabled == option.OptionDisabled {
fmt.Printf("%-24s %s\n", k, color.Red("Disabled"))
} else {
fmt.Printf("%-24s %s\n", k, color.Green("Enabled"))
}
}
} | go | func dumpConfig(Opts map[string]string) {
opts := []string{}
for k := range Opts {
opts = append(opts, k)
}
sort.Strings(opts)
for _, k := range opts {
// XXX: Reuse the format function from *option.Library
value = Opts[k]
if enabled, err := option.NormalizeBool(value); err != nil {
// If it cannot be parsed as a bool, just format the value.
fmt.Printf("%-24s %s\n", k, color.Green(value))
} else if enabled == option.OptionDisabled {
fmt.Printf("%-24s %s\n", k, color.Red("Disabled"))
} else {
fmt.Printf("%-24s %s\n", k, color.Green("Enabled"))
}
}
} | [
"func",
"dumpConfig",
"(",
"Opts",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"opts",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"k",
":=",
"range",
"Opts",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"opts",
")",
"\n\n",
"for",
"_",
",",
"k",
":=",
"range",
"opts",
"{",
"// XXX: Reuse the format function from *option.Library",
"value",
"=",
"Opts",
"[",
"k",
"]",
"\n",
"if",
"enabled",
",",
"err",
":=",
"option",
".",
"NormalizeBool",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"// If it cannot be parsed as a bool, just format the value.",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"color",
".",
"Green",
"(",
"value",
")",
")",
"\n",
"}",
"else",
"if",
"enabled",
"==",
"option",
".",
"OptionDisabled",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"color",
".",
"Red",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"color",
".",
"Green",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // dumpConfig pretty prints boolean options | [
"dumpConfig",
"pretty",
"prints",
"boolean",
"options"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/cilium/cmd/helpers.go#L353-L372 |
162,386 | cilium/cilium | pkg/envoy/server.go | RemoveListener | func (s *XDSServer) RemoveListener(name string, wg *completion.WaitGroup) xds.AckingResourceMutatorRevertFunc {
log.Debugf("Envoy: removeListener %s", name)
var listenerRevertFunc func(*completion.Completion)
s.mutex.Lock()
listener, ok := s.listeners[name]
if ok && listener != nil {
listener.count--
if listener.count == 0 {
delete(s.listeners, name)
listenerRevertFunc = s.listenerMutator.Delete(ListenerTypeURL, name, []string{"127.0.0.1"}, wg.AddCompletion())
}
} else {
// Bail out if this listener does not exist
log.Fatalf("Envoy: Attempt to remove non-existent listener: %s", name)
}
s.mutex.Unlock()
return func(completion *completion.Completion) {
s.mutex.Lock()
if listenerRevertFunc != nil {
listenerRevertFunc(completion)
}
listener.count++
s.listeners[name] = listener
s.mutex.Unlock()
}
} | go | func (s *XDSServer) RemoveListener(name string, wg *completion.WaitGroup) xds.AckingResourceMutatorRevertFunc {
log.Debugf("Envoy: removeListener %s", name)
var listenerRevertFunc func(*completion.Completion)
s.mutex.Lock()
listener, ok := s.listeners[name]
if ok && listener != nil {
listener.count--
if listener.count == 0 {
delete(s.listeners, name)
listenerRevertFunc = s.listenerMutator.Delete(ListenerTypeURL, name, []string{"127.0.0.1"}, wg.AddCompletion())
}
} else {
// Bail out if this listener does not exist
log.Fatalf("Envoy: Attempt to remove non-existent listener: %s", name)
}
s.mutex.Unlock()
return func(completion *completion.Completion) {
s.mutex.Lock()
if listenerRevertFunc != nil {
listenerRevertFunc(completion)
}
listener.count++
s.listeners[name] = listener
s.mutex.Unlock()
}
} | [
"func",
"(",
"s",
"*",
"XDSServer",
")",
"RemoveListener",
"(",
"name",
"string",
",",
"wg",
"*",
"completion",
".",
"WaitGroup",
")",
"xds",
".",
"AckingResourceMutatorRevertFunc",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n\n",
"var",
"listenerRevertFunc",
"func",
"(",
"*",
"completion",
".",
"Completion",
")",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"listener",
",",
"ok",
":=",
"s",
".",
"listeners",
"[",
"name",
"]",
"\n",
"if",
"ok",
"&&",
"listener",
"!=",
"nil",
"{",
"listener",
".",
"count",
"--",
"\n",
"if",
"listener",
".",
"count",
"==",
"0",
"{",
"delete",
"(",
"s",
".",
"listeners",
",",
"name",
")",
"\n",
"listenerRevertFunc",
"=",
"s",
".",
"listenerMutator",
".",
"Delete",
"(",
"ListenerTypeURL",
",",
"name",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"wg",
".",
"AddCompletion",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Bail out if this listener does not exist",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"func",
"(",
"completion",
"*",
"completion",
".",
"Completion",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"listenerRevertFunc",
"!=",
"nil",
"{",
"listenerRevertFunc",
"(",
"completion",
")",
"\n",
"}",
"\n",
"listener",
".",
"count",
"++",
"\n",
"s",
".",
"listeners",
"[",
"name",
"]",
"=",
"listener",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // RemoveListener removes an existing Envoy Listener. | [
"RemoveListener",
"removes",
"an",
"existing",
"Envoy",
"Listener",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/server.go#L404-L432 |
162,387 | cilium/cilium | pkg/envoy/server.go | getNetworkPolicy | func getNetworkPolicy(name string, id identity.NumericIdentity, conntrackName string, policy *policy.L4Policy,
ingressPolicyEnforced, egressPolicyEnforced bool, labelsMap,
deniedIngressIdentities, deniedEgressIdentities cache.IdentityCache) *cilium.NetworkPolicy {
p := &cilium.NetworkPolicy{
Name: name,
Policy: uint64(id),
ConntrackMapName: conntrackName,
}
// If no policy, deny all traffic. Otherwise, convert the policies for ingress and egress.
if policy != nil {
p.IngressPerPortPolicies = getDirectionNetworkPolicy(policy.Ingress, ingressPolicyEnforced, labelsMap, deniedIngressIdentities)
p.EgressPerPortPolicies = getDirectionNetworkPolicy(policy.Egress, egressPolicyEnforced, labelsMap, deniedEgressIdentities)
}
return p
} | go | func getNetworkPolicy(name string, id identity.NumericIdentity, conntrackName string, policy *policy.L4Policy,
ingressPolicyEnforced, egressPolicyEnforced bool, labelsMap,
deniedIngressIdentities, deniedEgressIdentities cache.IdentityCache) *cilium.NetworkPolicy {
p := &cilium.NetworkPolicy{
Name: name,
Policy: uint64(id),
ConntrackMapName: conntrackName,
}
// If no policy, deny all traffic. Otherwise, convert the policies for ingress and egress.
if policy != nil {
p.IngressPerPortPolicies = getDirectionNetworkPolicy(policy.Ingress, ingressPolicyEnforced, labelsMap, deniedIngressIdentities)
p.EgressPerPortPolicies = getDirectionNetworkPolicy(policy.Egress, egressPolicyEnforced, labelsMap, deniedEgressIdentities)
}
return p
} | [
"func",
"getNetworkPolicy",
"(",
"name",
"string",
",",
"id",
"identity",
".",
"NumericIdentity",
",",
"conntrackName",
"string",
",",
"policy",
"*",
"policy",
".",
"L4Policy",
",",
"ingressPolicyEnforced",
",",
"egressPolicyEnforced",
"bool",
",",
"labelsMap",
",",
"deniedIngressIdentities",
",",
"deniedEgressIdentities",
"cache",
".",
"IdentityCache",
")",
"*",
"cilium",
".",
"NetworkPolicy",
"{",
"p",
":=",
"&",
"cilium",
".",
"NetworkPolicy",
"{",
"Name",
":",
"name",
",",
"Policy",
":",
"uint64",
"(",
"id",
")",
",",
"ConntrackMapName",
":",
"conntrackName",
",",
"}",
"\n\n",
"// If no policy, deny all traffic. Otherwise, convert the policies for ingress and egress.",
"if",
"policy",
"!=",
"nil",
"{",
"p",
".",
"IngressPerPortPolicies",
"=",
"getDirectionNetworkPolicy",
"(",
"policy",
".",
"Ingress",
",",
"ingressPolicyEnforced",
",",
"labelsMap",
",",
"deniedIngressIdentities",
")",
"\n",
"p",
".",
"EgressPerPortPolicies",
"=",
"getDirectionNetworkPolicy",
"(",
"policy",
".",
"Egress",
",",
"egressPolicyEnforced",
",",
"labelsMap",
",",
"deniedEgressIdentities",
")",
"\n",
"}",
"\n\n",
"return",
"p",
"\n",
"}"
] | // getNetworkPolicy converts a network policy into a cilium.NetworkPolicy. | [
"getNetworkPolicy",
"converts",
"a",
"network",
"policy",
"into",
"a",
"cilium",
".",
"NetworkPolicy",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/server.go#L728-L744 |
162,388 | cilium/cilium | pkg/envoy/server.go | RemoveNetworkPolicy | func (s *XDSServer) RemoveNetworkPolicy(ep logger.EndpointInfoSource) {
s.mutex.Lock()
defer s.mutex.Unlock()
if ep.GetIPv6Address() != "" {
name := ep.GetIPv6Address()
s.networkPolicyCache.Delete(NetworkPolicyTypeURL, name, false)
delete(s.networkPolicyEndpoints, name)
}
if ep.GetIPv4Address() != "" {
name := ep.GetIPv4Address()
s.networkPolicyCache.Delete(NetworkPolicyTypeURL, name, false)
delete(s.networkPolicyEndpoints, name)
}
} | go | func (s *XDSServer) RemoveNetworkPolicy(ep logger.EndpointInfoSource) {
s.mutex.Lock()
defer s.mutex.Unlock()
if ep.GetIPv6Address() != "" {
name := ep.GetIPv6Address()
s.networkPolicyCache.Delete(NetworkPolicyTypeURL, name, false)
delete(s.networkPolicyEndpoints, name)
}
if ep.GetIPv4Address() != "" {
name := ep.GetIPv4Address()
s.networkPolicyCache.Delete(NetworkPolicyTypeURL, name, false)
delete(s.networkPolicyEndpoints, name)
}
} | [
"func",
"(",
"s",
"*",
"XDSServer",
")",
"RemoveNetworkPolicy",
"(",
"ep",
"logger",
".",
"EndpointInfoSource",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"ep",
".",
"GetIPv6Address",
"(",
")",
"!=",
"\"",
"\"",
"{",
"name",
":=",
"ep",
".",
"GetIPv6Address",
"(",
")",
"\n",
"s",
".",
"networkPolicyCache",
".",
"Delete",
"(",
"NetworkPolicyTypeURL",
",",
"name",
",",
"false",
")",
"\n",
"delete",
"(",
"s",
".",
"networkPolicyEndpoints",
",",
"name",
")",
"\n",
"}",
"\n",
"if",
"ep",
".",
"GetIPv4Address",
"(",
")",
"!=",
"\"",
"\"",
"{",
"name",
":=",
"ep",
".",
"GetIPv4Address",
"(",
")",
"\n",
"s",
".",
"networkPolicyCache",
".",
"Delete",
"(",
"NetworkPolicyTypeURL",
",",
"name",
",",
"false",
")",
"\n",
"delete",
"(",
"s",
".",
"networkPolicyEndpoints",
",",
"name",
")",
"\n",
"}",
"\n",
"}"
] | // RemoveNetworkPolicy removes network policies relevant to the specified
// endpoint from the set published to L7 proxies, and stops listening for
// acks for policies on this endpoint. | [
"RemoveNetworkPolicy",
"removes",
"network",
"policies",
"relevant",
"to",
"the",
"specified",
"endpoint",
"from",
"the",
"set",
"published",
"to",
"L7",
"proxies",
"and",
"stops",
"listening",
"for",
"acks",
"for",
"policies",
"on",
"this",
"endpoint",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/server.go#L874-L888 |
162,389 | cilium/cilium | pkg/envoy/server.go | GetNetworkPolicies | func (s *XDSServer) GetNetworkPolicies(resourceNames []string) (map[string]*cilium.NetworkPolicy, error) {
resources, err := s.networkPolicyCache.GetResources(context.Background(), NetworkPolicyTypeURL, 0, nil, resourceNames)
if err != nil {
return nil, err
}
networkPolicies := make(map[string]*cilium.NetworkPolicy, len(resources.Resources))
for _, res := range resources.Resources {
networkPolicy := res.(*cilium.NetworkPolicy)
networkPolicies[networkPolicy.Name] = networkPolicy
}
return networkPolicies, nil
} | go | func (s *XDSServer) GetNetworkPolicies(resourceNames []string) (map[string]*cilium.NetworkPolicy, error) {
resources, err := s.networkPolicyCache.GetResources(context.Background(), NetworkPolicyTypeURL, 0, nil, resourceNames)
if err != nil {
return nil, err
}
networkPolicies := make(map[string]*cilium.NetworkPolicy, len(resources.Resources))
for _, res := range resources.Resources {
networkPolicy := res.(*cilium.NetworkPolicy)
networkPolicies[networkPolicy.Name] = networkPolicy
}
return networkPolicies, nil
} | [
"func",
"(",
"s",
"*",
"XDSServer",
")",
"GetNetworkPolicies",
"(",
"resourceNames",
"[",
"]",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"cilium",
".",
"NetworkPolicy",
",",
"error",
")",
"{",
"resources",
",",
"err",
":=",
"s",
".",
"networkPolicyCache",
".",
"GetResources",
"(",
"context",
".",
"Background",
"(",
")",
",",
"NetworkPolicyTypeURL",
",",
"0",
",",
"nil",
",",
"resourceNames",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"networkPolicies",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"cilium",
".",
"NetworkPolicy",
",",
"len",
"(",
"resources",
".",
"Resources",
")",
")",
"\n",
"for",
"_",
",",
"res",
":=",
"range",
"resources",
".",
"Resources",
"{",
"networkPolicy",
":=",
"res",
".",
"(",
"*",
"cilium",
".",
"NetworkPolicy",
")",
"\n",
"networkPolicies",
"[",
"networkPolicy",
".",
"Name",
"]",
"=",
"networkPolicy",
"\n",
"}",
"\n",
"return",
"networkPolicies",
",",
"nil",
"\n",
"}"
] | // GetNetworkPolicies returns the current version of the network policies with
// the given names.
// If resourceNames is empty, all resources are returned. | [
"GetNetworkPolicies",
"returns",
"the",
"current",
"version",
"of",
"the",
"network",
"policies",
"with",
"the",
"given",
"names",
".",
"If",
"resourceNames",
"is",
"empty",
"all",
"resources",
"are",
"returned",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/server.go#L899-L910 |
162,390 | cilium/cilium | pkg/envoy/server.go | getLocalEndpoint | func (s *XDSServer) getLocalEndpoint(networkPolicyName string) logger.EndpointUpdater {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.networkPolicyEndpoints[networkPolicyName]
} | go | func (s *XDSServer) getLocalEndpoint(networkPolicyName string) logger.EndpointUpdater {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.networkPolicyEndpoints[networkPolicyName]
} | [
"func",
"(",
"s",
"*",
"XDSServer",
")",
"getLocalEndpoint",
"(",
"networkPolicyName",
"string",
")",
"logger",
".",
"EndpointUpdater",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"networkPolicyEndpoints",
"[",
"networkPolicyName",
"]",
"\n",
"}"
] | // getLocalEndpoint returns the endpoint info for the local endpoint on which
// the network policy of the given name if enforced, or nil if not found. | [
"getLocalEndpoint",
"returns",
"the",
"endpoint",
"info",
"for",
"the",
"local",
"endpoint",
"on",
"which",
"the",
"network",
"policy",
"of",
"the",
"given",
"name",
"if",
"enforced",
"or",
"nil",
"if",
"not",
"found",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/server.go#L914-L919 |
162,391 | cilium/cilium | pkg/policy/api/utils.go | Equal | func (h *PortRuleHTTP) Equal(o PortRuleHTTP) bool {
if h.Path != o.Path ||
h.Method != o.Method ||
h.Host != o.Host ||
len(h.Headers) != len(o.Headers) {
return false
}
for i, value := range h.Headers {
if o.Headers[i] != value {
return false
}
}
return true
} | go | func (h *PortRuleHTTP) Equal(o PortRuleHTTP) bool {
if h.Path != o.Path ||
h.Method != o.Method ||
h.Host != o.Host ||
len(h.Headers) != len(o.Headers) {
return false
}
for i, value := range h.Headers {
if o.Headers[i] != value {
return false
}
}
return true
} | [
"func",
"(",
"h",
"*",
"PortRuleHTTP",
")",
"Equal",
"(",
"o",
"PortRuleHTTP",
")",
"bool",
"{",
"if",
"h",
".",
"Path",
"!=",
"o",
".",
"Path",
"||",
"h",
".",
"Method",
"!=",
"o",
".",
"Method",
"||",
"h",
".",
"Host",
"!=",
"o",
".",
"Host",
"||",
"len",
"(",
"h",
".",
"Headers",
")",
"!=",
"len",
"(",
"o",
".",
"Headers",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"value",
":=",
"range",
"h",
".",
"Headers",
"{",
"if",
"o",
".",
"Headers",
"[",
"i",
"]",
"!=",
"value",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Equal returns true if both HTTP rules are equal | [
"Equal",
"returns",
"true",
"if",
"both",
"HTTP",
"rules",
"are",
"equal"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L34-L48 |
162,392 | cilium/cilium | pkg/policy/api/utils.go | Exists | func (d *PortRuleDNS) Exists(rules L7Rules) bool {
for _, existingRule := range rules.DNS {
if d.Equal(existingRule) {
return true
}
}
return false
} | go | func (d *PortRuleDNS) Exists(rules L7Rules) bool {
for _, existingRule := range rules.DNS {
if d.Equal(existingRule) {
return true
}
}
return false
} | [
"func",
"(",
"d",
"*",
"PortRuleDNS",
")",
"Exists",
"(",
"rules",
"L7Rules",
")",
"bool",
"{",
"for",
"_",
",",
"existingRule",
":=",
"range",
"rules",
".",
"DNS",
"{",
"if",
"d",
".",
"Equal",
"(",
"existingRule",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Exists returns true if the DNS rule already exists in the list of rules | [
"Exists",
"returns",
"true",
"if",
"the",
"DNS",
"rule",
"already",
"exists",
"in",
"the",
"list",
"of",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L62-L70 |
162,393 | cilium/cilium | pkg/policy/api/utils.go | Exists | func (h *PortRuleL7) Exists(rules L7Rules) bool {
for _, existingRule := range rules.L7 {
if h.Equal(existingRule) {
return true
}
}
return false
} | go | func (h *PortRuleL7) Exists(rules L7Rules) bool {
for _, existingRule := range rules.L7 {
if h.Equal(existingRule) {
return true
}
}
return false
} | [
"func",
"(",
"h",
"*",
"PortRuleL7",
")",
"Exists",
"(",
"rules",
"L7Rules",
")",
"bool",
"{",
"for",
"_",
",",
"existingRule",
":=",
"range",
"rules",
".",
"L7",
"{",
"if",
"h",
".",
"Equal",
"(",
"existingRule",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Exists returns true if the L7 rule already exists in the list of rules | [
"Exists",
"returns",
"true",
"if",
"the",
"L7",
"rule",
"already",
"exists",
"in",
"the",
"list",
"of",
"rules"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L79-L87 |
162,394 | cilium/cilium | pkg/policy/api/utils.go | Equal | func (h *PortRuleL7) Equal(o PortRuleL7) bool {
if len(*h) != len(o) {
return false
}
for k, v := range *h {
if v2, ok := o[k]; !ok || v2 != v {
return false
}
}
return true
} | go | func (h *PortRuleL7) Equal(o PortRuleL7) bool {
if len(*h) != len(o) {
return false
}
for k, v := range *h {
if v2, ok := o[k]; !ok || v2 != v {
return false
}
}
return true
} | [
"func",
"(",
"h",
"*",
"PortRuleL7",
")",
"Equal",
"(",
"o",
"PortRuleL7",
")",
"bool",
"{",
"if",
"len",
"(",
"*",
"h",
")",
"!=",
"len",
"(",
"o",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"*",
"h",
"{",
"if",
"v2",
",",
"ok",
":=",
"o",
"[",
"k",
"]",
";",
"!",
"ok",
"||",
"v2",
"!=",
"v",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Equal returns true if both L7 rules are equal | [
"Equal",
"returns",
"true",
"if",
"both",
"L7",
"rules",
"are",
"equal"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L95-L105 |
162,395 | cilium/cilium | pkg/policy/api/utils.go | Validate | func (l4 L4Proto) Validate() error {
switch l4 {
case ProtoAny, ProtoTCP, ProtoUDP:
default:
return fmt.Errorf("invalid protocol %q, must be { tcp | udp | any }", l4)
}
return nil
} | go | func (l4 L4Proto) Validate() error {
switch l4 {
case ProtoAny, ProtoTCP, ProtoUDP:
default:
return fmt.Errorf("invalid protocol %q, must be { tcp | udp | any }", l4)
}
return nil
} | [
"func",
"(",
"l4",
"L4Proto",
")",
"Validate",
"(",
")",
"error",
"{",
"switch",
"l4",
"{",
"case",
"ProtoAny",
",",
"ProtoTCP",
",",
"ProtoUDP",
":",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l4",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Validate returns an error if the layer 4 protocol is not valid | [
"Validate",
"returns",
"an",
"error",
"if",
"the",
"layer",
"4",
"protocol",
"is",
"not",
"valid"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L108-L116 |
162,396 | cilium/cilium | pkg/policy/api/utils.go | ParseL4Proto | func ParseL4Proto(proto string) (L4Proto, error) {
if proto == "" {
return ProtoAny, nil
}
p := L4Proto(strings.ToUpper(proto))
return p, p.Validate()
} | go | func ParseL4Proto(proto string) (L4Proto, error) {
if proto == "" {
return ProtoAny, nil
}
p := L4Proto(strings.ToUpper(proto))
return p, p.Validate()
} | [
"func",
"ParseL4Proto",
"(",
"proto",
"string",
")",
"(",
"L4Proto",
",",
"error",
")",
"{",
"if",
"proto",
"==",
"\"",
"\"",
"{",
"return",
"ProtoAny",
",",
"nil",
"\n",
"}",
"\n\n",
"p",
":=",
"L4Proto",
"(",
"strings",
".",
"ToUpper",
"(",
"proto",
")",
")",
"\n",
"return",
"p",
",",
"p",
".",
"Validate",
"(",
")",
"\n",
"}"
] | // ParseL4Proto parses a string as layer 4 protocol | [
"ParseL4Proto",
"parses",
"a",
"string",
"as",
"layer",
"4",
"protocol"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/utils.go#L119-L126 |
162,397 | cilium/cilium | pkg/datapath/maps/map.go | removeDatapathMapping | func (gw *realEPManager) removeDatapathMapping(endpointID uint16) error {
return policymap.RemoveGlobalMapping(uint32(endpointID))
} | go | func (gw *realEPManager) removeDatapathMapping(endpointID uint16) error {
return policymap.RemoveGlobalMapping(uint32(endpointID))
} | [
"func",
"(",
"gw",
"*",
"realEPManager",
")",
"removeDatapathMapping",
"(",
"endpointID",
"uint16",
")",
"error",
"{",
"return",
"policymap",
".",
"RemoveGlobalMapping",
"(",
"uint32",
"(",
"endpointID",
")",
")",
"\n",
"}"
] | // removeDatapathMapping unlinks the endpointID from the global policy map, preventing
// packets that arrive on this node from being forwarded to the endpoint that
// used to exist with the specified ID. | [
"removeDatapathMapping",
"unlinks",
"the",
"endpointID",
"from",
"the",
"global",
"policy",
"map",
"preventing",
"packets",
"that",
"arrive",
"on",
"this",
"node",
"from",
"being",
"forwarded",
"to",
"the",
"endpoint",
"that",
"used",
"to",
"exist",
"with",
"the",
"specified",
"ID",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/maps/map.go#L68-L70 |
162,398 | cilium/cilium | pkg/datapath/maps/map.go | removeMapPath | func (gw *realEPManager) removeMapPath(path string) {
if err := os.RemoveAll(path); err != nil {
log.WithError(err).WithField(logfields.Path, path).Warn("Error while deleting stale map file")
} else {
log.WithField(logfields.Path, path).Info("Removed stale bpf map")
}
} | go | func (gw *realEPManager) removeMapPath(path string) {
if err := os.RemoveAll(path); err != nil {
log.WithError(err).WithField(logfields.Path, path).Warn("Error while deleting stale map file")
} else {
log.WithField(logfields.Path, path).Info("Removed stale bpf map")
}
} | [
"func",
"(",
"gw",
"*",
"realEPManager",
")",
"removeMapPath",
"(",
"path",
"string",
")",
"{",
"if",
"err",
":=",
"os",
".",
"RemoveAll",
"(",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err",
")",
".",
"WithField",
"(",
"logfields",
".",
"Path",
",",
"path",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"WithField",
"(",
"logfields",
".",
"Path",
",",
"path",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // removeMapPath removes the specified path from the filesystem. | [
"removeMapPath",
"removes",
"the",
"specified",
"path",
"from",
"the",
"filesystem",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/maps/map.go#L73-L79 |
162,399 | cilium/cilium | pkg/datapath/maps/map.go | deleteMapIfStale | func (ms *mapSweeper) deleteMapIfStale(path string, filename string, endpointID string) {
if tmp, err := strconv.ParseUint(endpointID, 10, 16); err == nil {
epID := uint16(tmp)
if ms.endpointExists(epID) {
prefix := strings.TrimSuffix(filename, endpointID)
if filename != bpf.LocalMapName(prefix, epID) {
ms.removeMapPath(path)
}
} else {
err2 := ms.removeDatapathMapping(epID)
if err2 != nil {
log.WithError(err2).Debugf("Failed to remove ID %d from global policy map", tmp)
}
ms.removeMapPath(path)
}
}
} | go | func (ms *mapSweeper) deleteMapIfStale(path string, filename string, endpointID string) {
if tmp, err := strconv.ParseUint(endpointID, 10, 16); err == nil {
epID := uint16(tmp)
if ms.endpointExists(epID) {
prefix := strings.TrimSuffix(filename, endpointID)
if filename != bpf.LocalMapName(prefix, epID) {
ms.removeMapPath(path)
}
} else {
err2 := ms.removeDatapathMapping(epID)
if err2 != nil {
log.WithError(err2).Debugf("Failed to remove ID %d from global policy map", tmp)
}
ms.removeMapPath(path)
}
}
} | [
"func",
"(",
"ms",
"*",
"mapSweeper",
")",
"deleteMapIfStale",
"(",
"path",
"string",
",",
"filename",
"string",
",",
"endpointID",
"string",
")",
"{",
"if",
"tmp",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"endpointID",
",",
"10",
",",
"16",
")",
";",
"err",
"==",
"nil",
"{",
"epID",
":=",
"uint16",
"(",
"tmp",
")",
"\n",
"if",
"ms",
".",
"endpointExists",
"(",
"epID",
")",
"{",
"prefix",
":=",
"strings",
".",
"TrimSuffix",
"(",
"filename",
",",
"endpointID",
")",
"\n",
"if",
"filename",
"!=",
"bpf",
".",
"LocalMapName",
"(",
"prefix",
",",
"epID",
")",
"{",
"ms",
".",
"removeMapPath",
"(",
"path",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err2",
":=",
"ms",
".",
"removeDatapathMapping",
"(",
"epID",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"log",
".",
"WithError",
"(",
"err2",
")",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"tmp",
")",
"\n",
"}",
"\n",
"ms",
".",
"removeMapPath",
"(",
"path",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // deleteMapIfStale uses the endpointManager implementation to determine for
// the given path whether it should be deleted, and if so deletes the path. | [
"deleteMapIfStale",
"uses",
"the",
"endpointManager",
"implementation",
"to",
"determine",
"for",
"the",
"given",
"path",
"whether",
"it",
"should",
"be",
"deleted",
"and",
"if",
"so",
"deletes",
"the",
"path",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/datapath/maps/map.go#L98-L114 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.