id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
163,700 | cilium/cilium | pkg/k8s/service.go | ParseServiceID | func ParseServiceID(svc *types.Service) ServiceID {
return ServiceID{
Name: svc.ObjectMeta.Name,
Namespace: svc.ObjectMeta.Namespace,
}
} | go | func ParseServiceID(svc *types.Service) ServiceID {
return ServiceID{
Name: svc.ObjectMeta.Name,
Namespace: svc.ObjectMeta.Namespace,
}
} | [
"func",
"ParseServiceID",
"(",
"svc",
"*",
"types",
".",
"Service",
")",
"ServiceID",
"{",
"return",
"ServiceID",
"{",
"Name",
":",
"svc",
".",
"ObjectMeta",
".",
"Name",
",",
"Namespace",
":",
"svc",
".",
"ObjectMeta",
".",
"Namespace",
",",
"}",
"\n",
... | // ParseServiceID parses a Kubernetes service and returns the ServiceID | [
"ParseServiceID",
"parses",
"a",
"Kubernetes",
"service",
"and",
"returns",
"the",
"ServiceID"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L50-L55 |
163,701 | cilium/cilium | pkg/k8s/service.go | ParseService | func ParseService(svc *types.Service) (ServiceID, *Service) {
scopedLog := log.WithFields(logrus.Fields{
logfields.K8sSvcName: svc.ObjectMeta.Name,
logfields.K8sNamespace: svc.ObjectMeta.Namespace,
logfields.K8sAPIVersion: svc.TypeMeta.APIVersion,
logfields.K8sSvcType: svc.Spec.Type,
})
svcID := ParseServiceID(svc)
switch svc.Spec.Type {
case v1.ServiceTypeClusterIP, v1.ServiceTypeNodePort, v1.ServiceTypeLoadBalancer:
break
case v1.ServiceTypeExternalName:
// External-name services must be ignored
return svcID, nil
default:
scopedLog.Warn("Ignoring k8s service: unsupported type")
return svcID, nil
}
if svc.Spec.ClusterIP == "" {
return svcID, nil
}
clusterIP := net.ParseIP(svc.Spec.ClusterIP)
headless := false
if strings.ToLower(svc.Spec.ClusterIP) == "none" {
headless = true
}
svcInfo := NewService(clusterIP, headless, svc.Labels, svc.Spec.Selector)
svcInfo.IncludeExternal = getAnnotationIncludeExternal(svc)
svcInfo.Shared = getAnnotationShared(svc)
// FIXME: Add support for
// - NodePort
for _, port := range svc.Spec.Ports {
p := loadbalancer.NewFEPort(loadbalancer.L4Type(port.Protocol), uint16(port.Port))
if _, ok := svcInfo.Ports[loadbalancer.FEPortName(port.Name)]; !ok {
svcInfo.Ports[loadbalancer.FEPortName(port.Name)] = p
}
}
return svcID, svcInfo
} | go | func ParseService(svc *types.Service) (ServiceID, *Service) {
scopedLog := log.WithFields(logrus.Fields{
logfields.K8sSvcName: svc.ObjectMeta.Name,
logfields.K8sNamespace: svc.ObjectMeta.Namespace,
logfields.K8sAPIVersion: svc.TypeMeta.APIVersion,
logfields.K8sSvcType: svc.Spec.Type,
})
svcID := ParseServiceID(svc)
switch svc.Spec.Type {
case v1.ServiceTypeClusterIP, v1.ServiceTypeNodePort, v1.ServiceTypeLoadBalancer:
break
case v1.ServiceTypeExternalName:
// External-name services must be ignored
return svcID, nil
default:
scopedLog.Warn("Ignoring k8s service: unsupported type")
return svcID, nil
}
if svc.Spec.ClusterIP == "" {
return svcID, nil
}
clusterIP := net.ParseIP(svc.Spec.ClusterIP)
headless := false
if strings.ToLower(svc.Spec.ClusterIP) == "none" {
headless = true
}
svcInfo := NewService(clusterIP, headless, svc.Labels, svc.Spec.Selector)
svcInfo.IncludeExternal = getAnnotationIncludeExternal(svc)
svcInfo.Shared = getAnnotationShared(svc)
// FIXME: Add support for
// - NodePort
for _, port := range svc.Spec.Ports {
p := loadbalancer.NewFEPort(loadbalancer.L4Type(port.Protocol), uint16(port.Port))
if _, ok := svcInfo.Ports[loadbalancer.FEPortName(port.Name)]; !ok {
svcInfo.Ports[loadbalancer.FEPortName(port.Name)] = p
}
}
return svcID, svcInfo
} | [
"func",
"ParseService",
"(",
"svc",
"*",
"types",
".",
"Service",
")",
"(",
"ServiceID",
",",
"*",
"Service",
")",
"{",
"scopedLog",
":=",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"logfields",
".",
"K8sSvcName",
":",
"svc",
".",
"Ob... | // ParseService parses a Kubernetes service and returns a Service | [
"ParseService",
"parses",
"a",
"Kubernetes",
"service",
"and",
"returns",
"a",
"Service"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L58-L104 |
163,702 | cilium/cilium | pkg/k8s/service.go | String | func (s ServiceID) String() string {
return fmt.Sprintf("%s/%s", s.Namespace, s.Name)
} | go | func (s ServiceID) String() string {
return fmt.Sprintf("%s/%s", s.Namespace, s.Name)
} | [
"func",
"(",
"s",
"ServiceID",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"Namespace",
",",
"s",
".",
"Name",
")",
"\n",
"}"
] | // String returns the string representation of a service ID | [
"String",
"returns",
"the",
"string",
"representation",
"of",
"a",
"service",
"ID"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L113-L115 |
163,703 | cilium/cilium | pkg/k8s/service.go | ParseServiceIDFrom | func ParseServiceIDFrom(dn string) *ServiceID {
// typical service name "cilium-etcd-client.kube-system.svc"
idx1 := strings.IndexByte(dn, '.')
if idx1 >= 0 {
svc := ServiceID{
Name: dn[:idx1],
}
idx2 := strings.IndexByte(dn[idx1+1:], '.')
if idx2 >= 0 {
// "cilium-etcd-client.kube-system.svc"
// ^idx1+1 ^ idx1+1+idx2
svc.Namespace = dn[idx1+1 : idx1+1+idx2]
} else {
// "cilium-etcd-client.kube-system"
// ^idx1+1
svc.Namespace = dn[idx1+1:]
}
return &svc
}
return nil
} | go | func ParseServiceIDFrom(dn string) *ServiceID {
// typical service name "cilium-etcd-client.kube-system.svc"
idx1 := strings.IndexByte(dn, '.')
if idx1 >= 0 {
svc := ServiceID{
Name: dn[:idx1],
}
idx2 := strings.IndexByte(dn[idx1+1:], '.')
if idx2 >= 0 {
// "cilium-etcd-client.kube-system.svc"
// ^idx1+1 ^ idx1+1+idx2
svc.Namespace = dn[idx1+1 : idx1+1+idx2]
} else {
// "cilium-etcd-client.kube-system"
// ^idx1+1
svc.Namespace = dn[idx1+1:]
}
return &svc
}
return nil
} | [
"func",
"ParseServiceIDFrom",
"(",
"dn",
"string",
")",
"*",
"ServiceID",
"{",
"// typical service name \"cilium-etcd-client.kube-system.svc\"",
"idx1",
":=",
"strings",
".",
"IndexByte",
"(",
"dn",
",",
"'.'",
")",
"\n",
"if",
"idx1",
">=",
"0",
"{",
"svc",
":=... | // ParseServiceIDFrom returns a ServiceID derived from the given kubernetes
// service FQDN. | [
"ParseServiceIDFrom",
"returns",
"a",
"ServiceID",
"derived",
"from",
"the",
"given",
"kubernetes",
"service",
"FQDN",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L119-L139 |
163,704 | cilium/cilium | pkg/k8s/service.go | String | func (s *Service) String() string {
if s == nil {
return "nil"
}
ports := make([]string, len(s.Ports))
i := 0
for p := range s.Ports {
ports[i] = string(p)
i++
}
return fmt.Sprintf("frontend:%s/ports=%s/selector=%v", s.FrontendIP.String(), ports, s.Selector)
} | go | func (s *Service) String() string {
if s == nil {
return "nil"
}
ports := make([]string, len(s.Ports))
i := 0
for p := range s.Ports {
ports[i] = string(p)
i++
}
return fmt.Sprintf("frontend:%s/ports=%s/selector=%v", s.FrontendIP.String(), ports, s.Selector)
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"String",
"(",
")",
"string",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"ports",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"s",
".",
"Ports",
")",
")",
"\n"... | // String returns the string representation of a service resource | [
"String",
"returns",
"the",
"string",
"representation",
"of",
"a",
"service",
"resource"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L160-L173 |
163,705 | cilium/cilium | pkg/k8s/service.go | DeepEquals | func (s *Service) DeepEquals(o *Service) bool {
switch {
case (s == nil) != (o == nil):
return false
case (s == nil) && (o == nil):
return true
}
if s.IsHeadless == o.IsHeadless &&
s.FrontendIP.Equal(o.FrontendIP) &&
comparator.MapStringEquals(s.Labels, o.Labels) &&
comparator.MapStringEquals(s.Selector, o.Selector) {
if ((s.Ports == nil) != (o.Ports == nil)) ||
len(s.Ports) != len(o.Ports) {
return false
}
for portName, port := range s.Ports {
oPort, ok := o.Ports[portName]
if !ok {
return false
}
if !port.EqualsIgnoreID(oPort) {
return false
}
}
return true
}
return false
} | go | func (s *Service) DeepEquals(o *Service) bool {
switch {
case (s == nil) != (o == nil):
return false
case (s == nil) && (o == nil):
return true
}
if s.IsHeadless == o.IsHeadless &&
s.FrontendIP.Equal(o.FrontendIP) &&
comparator.MapStringEquals(s.Labels, o.Labels) &&
comparator.MapStringEquals(s.Selector, o.Selector) {
if ((s.Ports == nil) != (o.Ports == nil)) ||
len(s.Ports) != len(o.Ports) {
return false
}
for portName, port := range s.Ports {
oPort, ok := o.Ports[portName]
if !ok {
return false
}
if !port.EqualsIgnoreID(oPort) {
return false
}
}
return true
}
return false
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"DeepEquals",
"(",
"o",
"*",
"Service",
")",
"bool",
"{",
"switch",
"{",
"case",
"(",
"s",
"==",
"nil",
")",
"!=",
"(",
"o",
"==",
"nil",
")",
":",
"return",
"false",
"\n",
"case",
"(",
"s",
"==",
"nil",
... | // DeepEquals returns true if both services are equal | [
"DeepEquals",
"returns",
"true",
"if",
"both",
"services",
"are",
"equal"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L181-L209 |
163,706 | cilium/cilium | pkg/k8s/service.go | NewService | func NewService(ip net.IP, headless bool, labels map[string]string, selector map[string]string) *Service {
return &Service{
FrontendIP: ip,
IsHeadless: headless,
Ports: map[loadbalancer.FEPortName]*loadbalancer.FEPort{},
Labels: labels,
Selector: selector,
}
} | go | func NewService(ip net.IP, headless bool, labels map[string]string, selector map[string]string) *Service {
return &Service{
FrontendIP: ip,
IsHeadless: headless,
Ports: map[loadbalancer.FEPortName]*loadbalancer.FEPort{},
Labels: labels,
Selector: selector,
}
} | [
"func",
"NewService",
"(",
"ip",
"net",
".",
"IP",
",",
"headless",
"bool",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"selector",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"Service",
"{",
"return",
"&",
"Service",
"{",
"FrontendIP",... | // NewService returns a new Service with the Ports map initialized. | [
"NewService",
"returns",
"a",
"new",
"Service",
"with",
"the",
"Ports",
"map",
"initialized",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L212-L220 |
163,707 | cilium/cilium | pkg/k8s/service.go | UniquePorts | func (s *Service) UniquePorts() map[uint16]bool {
// We are not discriminating the different L4 protocols on the same L4
// port so we create the number of unique sets of service IP + service
// port.
uniqPorts := map[uint16]bool{}
for _, p := range s.Ports {
uniqPorts[p.Port] = true
}
return uniqPorts
} | go | func (s *Service) UniquePorts() map[uint16]bool {
// We are not discriminating the different L4 protocols on the same L4
// port so we create the number of unique sets of service IP + service
// port.
uniqPorts := map[uint16]bool{}
for _, p := range s.Ports {
uniqPorts[p.Port] = true
}
return uniqPorts
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"UniquePorts",
"(",
")",
"map",
"[",
"uint16",
"]",
"bool",
"{",
"// We are not discriminating the different L4 protocols on the same L4",
"// port so we create the number of unique sets of service IP + service",
"// port.",
"uniqPorts",
"... | // UniquePorts returns a map of all unique ports configured in the service | [
"UniquePorts",
"returns",
"a",
"map",
"of",
"all",
"unique",
"ports",
"configured",
"in",
"the",
"service"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L223-L232 |
163,708 | cilium/cilium | pkg/k8s/service.go | NewClusterService | func NewClusterService(id ServiceID, k8sService *Service, k8sEndpoints *Endpoints) service.ClusterService {
svc := service.NewClusterService(id.Name, id.Namespace)
for key, value := range k8sService.Labels {
svc.Labels[key] = value
}
for key, value := range k8sService.Selector {
svc.Selector[key] = value
}
portConfig := service.PortConfiguration{}
for portName, port := range k8sService.Ports {
portConfig[string(portName)] = port.L4Addr
}
svc.Frontends = map[string]service.PortConfiguration{}
svc.Frontends[k8sService.FrontendIP.String()] = portConfig
svc.Backends = map[string]service.PortConfiguration{}
for ipString, portConfig := range k8sEndpoints.Backends {
svc.Backends[ipString] = portConfig
}
return svc
} | go | func NewClusterService(id ServiceID, k8sService *Service, k8sEndpoints *Endpoints) service.ClusterService {
svc := service.NewClusterService(id.Name, id.Namespace)
for key, value := range k8sService.Labels {
svc.Labels[key] = value
}
for key, value := range k8sService.Selector {
svc.Selector[key] = value
}
portConfig := service.PortConfiguration{}
for portName, port := range k8sService.Ports {
portConfig[string(portName)] = port.L4Addr
}
svc.Frontends = map[string]service.PortConfiguration{}
svc.Frontends[k8sService.FrontendIP.String()] = portConfig
svc.Backends = map[string]service.PortConfiguration{}
for ipString, portConfig := range k8sEndpoints.Backends {
svc.Backends[ipString] = portConfig
}
return svc
} | [
"func",
"NewClusterService",
"(",
"id",
"ServiceID",
",",
"k8sService",
"*",
"Service",
",",
"k8sEndpoints",
"*",
"Endpoints",
")",
"service",
".",
"ClusterService",
"{",
"svc",
":=",
"service",
".",
"NewClusterService",
"(",
"id",
".",
"Name",
",",
"id",
".... | // NewClusterService returns the service.ClusterService representing a
// Kubernetes Service | [
"NewClusterService",
"returns",
"the",
"service",
".",
"ClusterService",
"representing",
"a",
"Kubernetes",
"Service"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/service.go#L236-L261 |
163,709 | cilium/cilium | pkg/service/store.go | DeepEquals | func (p PortConfiguration) DeepEquals(o PortConfiguration) bool {
if len(p) != len(o) {
return false
}
for portName1, port1 := range p {
port2, ok := o[portName1]
if !ok || !port1.Equals(port2) {
return false
}
}
return true
} | go | func (p PortConfiguration) DeepEquals(o PortConfiguration) bool {
if len(p) != len(o) {
return false
}
for portName1, port1 := range p {
port2, ok := o[portName1]
if !ok || !port1.Equals(port2) {
return false
}
}
return true
} | [
"func",
"(",
"p",
"PortConfiguration",
")",
"DeepEquals",
"(",
"o",
"PortConfiguration",
")",
"bool",
"{",
"if",
"len",
"(",
"p",
")",
"!=",
"len",
"(",
"o",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"portName1",
",",
"port1",
":=",
"ran... | // DeepEquals returns true if both PortConfigurations are identical | [
"DeepEquals",
"returns",
"true",
"if",
"both",
"PortConfigurations",
"are",
"identical"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/service/store.go#L40-L54 |
163,710 | cilium/cilium | pkg/service/store.go | GetKeyName | func (s *ClusterService) GetKeyName() string {
// WARNING - STABLE API: Changing the structure of the key may break
// backwards compatibility
return path.Join(s.Cluster, s.Namespace, s.Name)
} | go | func (s *ClusterService) GetKeyName() string {
// WARNING - STABLE API: Changing the structure of the key may break
// backwards compatibility
return path.Join(s.Cluster, s.Namespace, s.Name)
} | [
"func",
"(",
"s",
"*",
"ClusterService",
")",
"GetKeyName",
"(",
")",
"string",
"{",
"// WARNING - STABLE API: Changing the structure of the key may break",
"// backwards compatibility",
"return",
"path",
".",
"Join",
"(",
"s",
".",
"Cluster",
",",
"s",
".",
"Namespac... | // GetKeyName returns the kvstore key to be used for the global service | [
"GetKeyName",
"returns",
"the",
"kvstore",
"key",
"to",
"be",
"used",
"for",
"the",
"global",
"service"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/service/store.go#L96-L100 |
163,711 | cilium/cilium | pkg/service/store.go | Unmarshal | func (s *ClusterService) Unmarshal(data []byte) error {
newService := NewClusterService("", "")
if err := json.Unmarshal(data, &newService); err != nil {
return err
}
*s = newService
return nil
} | go | func (s *ClusterService) Unmarshal(data []byte) error {
newService := NewClusterService("", "")
if err := json.Unmarshal(data, &newService); err != nil {
return err
}
*s = newService
return nil
} | [
"func",
"(",
"s",
"*",
"ClusterService",
")",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"newService",
":=",
"NewClusterService",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"da... | // Unmarshal parses the JSON byte slice and updates the global service receiver | [
"Unmarshal",
"parses",
"the",
"JSON",
"byte",
"slice",
"and",
"updates",
"the",
"global",
"service",
"receiver"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/service/store.go#L113-L123 |
163,712 | cilium/cilium | pkg/service/store.go | NewClusterService | func NewClusterService(name, namespace string) ClusterService {
return ClusterService{
Name: name,
Namespace: namespace,
Frontends: map[string]PortConfiguration{},
Backends: map[string]PortConfiguration{},
Labels: map[string]string{},
Selector: map[string]string{},
}
} | go | func NewClusterService(name, namespace string) ClusterService {
return ClusterService{
Name: name,
Namespace: namespace,
Frontends: map[string]PortConfiguration{},
Backends: map[string]PortConfiguration{},
Labels: map[string]string{},
Selector: map[string]string{},
}
} | [
"func",
"NewClusterService",
"(",
"name",
",",
"namespace",
"string",
")",
"ClusterService",
"{",
"return",
"ClusterService",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"namespace",
",",
"Frontends",
":",
"map",
"[",
"string",
"]",
"PortConfiguration",
"... | // NewClusterService returns a new cluster service definition | [
"NewClusterService",
"returns",
"a",
"new",
"cluster",
"service",
"definition"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/service/store.go#L126-L135 |
163,713 | cilium/cilium | pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go | List | func (c *FakeCiliumEndpoints) List(opts v1.ListOptions) (result *v2.CiliumEndpointList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(ciliumendpointsResource, ciliumendpointsKind, c.ns, opts), &v2.CiliumEndpointList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v2.CiliumEndpointList{ListMeta: obj.(*v2.CiliumEndpointList).ListMeta}
for _, item := range obj.(*v2.CiliumEndpointList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
} | go | func (c *FakeCiliumEndpoints) List(opts v1.ListOptions) (result *v2.CiliumEndpointList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(ciliumendpointsResource, ciliumendpointsKind, c.ns, opts), &v2.CiliumEndpointList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v2.CiliumEndpointList{ListMeta: obj.(*v2.CiliumEndpointList).ListMeta}
for _, item := range obj.(*v2.CiliumEndpointList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
} | [
"func",
"(",
"c",
"*",
"FakeCiliumEndpoints",
")",
"List",
"(",
"opts",
"v1",
".",
"ListOptions",
")",
"(",
"result",
"*",
"v2",
".",
"CiliumEndpointList",
",",
"err",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Fake",
".",
"Invokes",
"(",... | // List takes label and field selectors, and returns the list of CiliumEndpoints that match those selectors. | [
"List",
"takes",
"label",
"and",
"field",
"selectors",
"and",
"returns",
"the",
"list",
"of",
"CiliumEndpoints",
"that",
"match",
"those",
"selectors",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go#L51-L70 |
163,714 | cilium/cilium | pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go | Watch | func (c *FakeCiliumEndpoints) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(ciliumendpointsResource, c.ns, opts))
} | go | func (c *FakeCiliumEndpoints) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(ciliumendpointsResource, c.ns, opts))
} | [
"func",
"(",
"c",
"*",
"FakeCiliumEndpoints",
")",
"Watch",
"(",
"opts",
"v1",
".",
"ListOptions",
")",
"(",
"watch",
".",
"Interface",
",",
"error",
")",
"{",
"return",
"c",
".",
"Fake",
".",
"InvokesWatch",
"(",
"testing",
".",
"NewWatchAction",
"(",
... | // Watch returns a watch.Interface that watches the requested ciliumEndpoints. | [
"Watch",
"returns",
"a",
"watch",
".",
"Interface",
"that",
"watches",
"the",
"requested",
"ciliumEndpoints",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go#L73-L77 |
163,715 | cilium/cilium | pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go | Delete | func (c *FakeCiliumEndpoints) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(ciliumendpointsResource, c.ns, name), &v2.CiliumEndpoint{})
return err
} | go | func (c *FakeCiliumEndpoints) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(ciliumendpointsResource, c.ns, name), &v2.CiliumEndpoint{})
return err
} | [
"func",
"(",
"c",
"*",
"FakeCiliumEndpoints",
")",
"Delete",
"(",
"name",
"string",
",",
"options",
"*",
"v1",
".",
"DeleteOptions",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Fake",
".",
"Invokes",
"(",
"testing",
".",
"NewDeleteAction",
"("... | // Delete takes name of the ciliumEndpoint and deletes it. Returns an error if one occurs. | [
"Delete",
"takes",
"name",
"of",
"the",
"ciliumEndpoint",
"and",
"deletes",
"it",
".",
"Returns",
"an",
"error",
"if",
"one",
"occurs",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/k8s/client/clientset/versioned/typed/cilium.io/v2/fake/fake_ciliumendpoint.go#L114-L119 |
163,716 | cilium/cilium | pkg/fqdn/helpers.go | getRuleUUIDLabel | func getRuleUUIDLabel(rule *api.Rule) (uuid string) {
return rule.Labels.Get(uuidLabelSearchKey)
} | go | func getRuleUUIDLabel(rule *api.Rule) (uuid string) {
return rule.Labels.Get(uuidLabelSearchKey)
} | [
"func",
"getRuleUUIDLabel",
"(",
"rule",
"*",
"api",
".",
"Rule",
")",
"(",
"uuid",
"string",
")",
"{",
"return",
"rule",
".",
"Labels",
".",
"Get",
"(",
"uuidLabelSearchKey",
")",
"\n",
"}"
] | // getUUIDFromRuleLabels returns the value of the UUID label | [
"getUUIDFromRuleLabels",
"returns",
"the",
"value",
"of",
"the",
"UUID",
"label"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L33-L35 |
163,717 | cilium/cilium | pkg/fqdn/helpers.go | generateUUIDLabel | func generateUUIDLabel() labels.Label {
return labels.NewLabel(generatedLabelNameUUID, uuid.NewUUID().String(), labels.LabelSourceCiliumGenerated)
} | go | func generateUUIDLabel() labels.Label {
return labels.NewLabel(generatedLabelNameUUID, uuid.NewUUID().String(), labels.LabelSourceCiliumGenerated)
} | [
"func",
"generateUUIDLabel",
"(",
")",
"labels",
".",
"Label",
"{",
"return",
"labels",
".",
"NewLabel",
"(",
"generatedLabelNameUUID",
",",
"uuid",
".",
"NewUUID",
"(",
")",
".",
"String",
"(",
")",
",",
"labels",
".",
"LabelSourceCiliumGenerated",
")",
"\n... | // generateUUIDLabel builds a random UUID label that can be used to uniquely identify
// rules augmented with a "toCIDRSet" based on "toFQDNs". | [
"generateUUIDLabel",
"builds",
"a",
"random",
"UUID",
"label",
"that",
"can",
"be",
"used",
"to",
"uniquely",
"identify",
"rules",
"augmented",
"with",
"a",
"toCIDRSet",
"based",
"on",
"toFQDNs",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L39-L41 |
163,718 | cilium/cilium | pkg/fqdn/helpers.go | stripToCIDRSet | func stripToCIDRSet(rule *api.Rule) {
for i := range rule.Egress {
egressRule := &rule.Egress[i]
if len(egressRule.ToFQDNs) > 0 {
egressRule.ToCIDRSet = nil
}
}
} | go | func stripToCIDRSet(rule *api.Rule) {
for i := range rule.Egress {
egressRule := &rule.Egress[i]
if len(egressRule.ToFQDNs) > 0 {
egressRule.ToCIDRSet = nil
}
}
} | [
"func",
"stripToCIDRSet",
"(",
"rule",
"*",
"api",
".",
"Rule",
")",
"{",
"for",
"i",
":=",
"range",
"rule",
".",
"Egress",
"{",
"egressRule",
":=",
"&",
"rule",
".",
"Egress",
"[",
"i",
"]",
"\n",
"if",
"len",
"(",
"egressRule",
".",
"ToFQDNs",
")... | // stripToCIDRSet ensures no ToCIDRSet is nil when ToFQDNs is non-nil | [
"stripToCIDRSet",
"ensures",
"no",
"ToCIDRSet",
"is",
"nil",
"when",
"ToFQDNs",
"is",
"non",
"-",
"nil"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L125-L132 |
163,719 | cilium/cilium | pkg/fqdn/helpers.go | hasToFQDN | func hasToFQDN(rule *api.Rule) bool {
for _, egressRule := range rule.Egress {
if len(egressRule.ToFQDNs) > 0 {
return true
}
}
return false
} | go | func hasToFQDN(rule *api.Rule) bool {
for _, egressRule := range rule.Egress {
if len(egressRule.ToFQDNs) > 0 {
return true
}
}
return false
} | [
"func",
"hasToFQDN",
"(",
"rule",
"*",
"api",
".",
"Rule",
")",
"bool",
"{",
"for",
"_",
",",
"egressRule",
":=",
"range",
"rule",
".",
"Egress",
"{",
"if",
"len",
"(",
"egressRule",
".",
"ToFQDNs",
")",
">",
"0",
"{",
"return",
"true",
"\n",
"}",
... | // hasToFQDN indicates whether a ToFQDN rule exists in the api.Rule | [
"hasToFQDN",
"indicates",
"whether",
"a",
"ToFQDN",
"rule",
"exists",
"in",
"the",
"api",
".",
"Rule"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L135-L143 |
163,720 | cilium/cilium | pkg/fqdn/helpers.go | sortedIPsAreEqual | func sortedIPsAreEqual(a, b []net.IP) bool {
// the IP set is definitely different if the lengths are different
if len(a) != len(b) {
return false
}
// lengths are equal, so each member in one set must be in the other
// Note: we sorted fullNewIPs above, and sorted oldIPs when they were
// inserted in this function, previously.
// If any IPs at the same index differ, updated = true.
for i := range a {
if !a[i].Equal(b[i]) {
return false
}
}
return true
} | go | func sortedIPsAreEqual(a, b []net.IP) bool {
// the IP set is definitely different if the lengths are different
if len(a) != len(b) {
return false
}
// lengths are equal, so each member in one set must be in the other
// Note: we sorted fullNewIPs above, and sorted oldIPs when they were
// inserted in this function, previously.
// If any IPs at the same index differ, updated = true.
for i := range a {
if !a[i].Equal(b[i]) {
return false
}
}
return true
} | [
"func",
"sortedIPsAreEqual",
"(",
"a",
",",
"b",
"[",
"]",
"net",
".",
"IP",
")",
"bool",
"{",
"// the IP set is definitely different if the lengths are different",
"if",
"len",
"(",
"a",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
"\n",
"}",
... | // sortedIPsAreEqual compares two lists of sorted IPs. If any differ it returns
// false. | [
"sortedIPsAreEqual",
"compares",
"two",
"lists",
"of",
"sorted",
"IPs",
".",
"If",
"any",
"differ",
"it",
"returns",
"false",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L147-L163 |
163,721 | cilium/cilium | pkg/fqdn/helpers.go | KeepUniqueNames | func KeepUniqueNames(names []string) []string {
result := []string{}
entries := map[string]bool{}
for _, item := range names {
if _, ok := entries[item]; ok {
continue
}
entries[item] = true
result = append(result, item)
}
return result
} | go | func KeepUniqueNames(names []string) []string {
result := []string{}
entries := map[string]bool{}
for _, item := range names {
if _, ok := entries[item]; ok {
continue
}
entries[item] = true
result = append(result, item)
}
return result
} | [
"func",
"KeepUniqueNames",
"(",
"names",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"result",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"entries",
":=",
"map",
"[",
"string",
"]",
"bool",
"{",
"}",
"\n\n",
"for",
"_",
",",
"item",
":=",
"r... | // KeepUniqueNames it gets a array of strings and return a new array of strings
// with the unique names. | [
"KeepUniqueNames",
"it",
"gets",
"a",
"array",
"of",
"strings",
"and",
"return",
"a",
"new",
"array",
"of",
"strings",
"with",
"the",
"unique",
"names",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/fqdn/helpers.go#L172-L184 |
163,722 | cilium/cilium | pkg/policy/api/rule_validation.go | Sanitize | func (r Rule) Sanitize() error {
// reject cilium-generated labels on insert.
// This isn't a proper function because r.Labels is a labels.LabelArray and
// not a labels.Labels, where we could add a function similar to GetReserved
for _, lbl := range r.Labels {
if lbl.Source == labels.LabelSourceCiliumGenerated {
return fmt.Errorf("rule labels cannot have cilium-generated source")
}
}
if r.EndpointSelector.LabelSelector == nil {
return fmt.Errorf("rule cannot have nil EndpointSelector")
}
if err := r.EndpointSelector.sanitize(); err != nil {
return err
}
for i := range r.Ingress {
if err := r.Ingress[i].sanitize(); err != nil {
return err
}
}
for i := range r.Egress {
if err := r.Egress[i].sanitize(); err != nil {
return err
}
}
return nil
} | go | func (r Rule) Sanitize() error {
// reject cilium-generated labels on insert.
// This isn't a proper function because r.Labels is a labels.LabelArray and
// not a labels.Labels, where we could add a function similar to GetReserved
for _, lbl := range r.Labels {
if lbl.Source == labels.LabelSourceCiliumGenerated {
return fmt.Errorf("rule labels cannot have cilium-generated source")
}
}
if r.EndpointSelector.LabelSelector == nil {
return fmt.Errorf("rule cannot have nil EndpointSelector")
}
if err := r.EndpointSelector.sanitize(); err != nil {
return err
}
for i := range r.Ingress {
if err := r.Ingress[i].sanitize(); err != nil {
return err
}
}
for i := range r.Egress {
if err := r.Egress[i].sanitize(); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"r",
"Rule",
")",
"Sanitize",
"(",
")",
"error",
"{",
"// reject cilium-generated labels on insert.",
"// This isn't a proper function because r.Labels is a labels.LabelArray and",
"// not a labels.Labels, where we could add a function similar to GetReserved",
"for",
"_",
... | // Sanitize validates and sanitizes a policy rule. Minor edits such as
// capitalization of the protocol name are automatically fixed up. More
// fundamental violations will cause an error to be returned. | [
"Sanitize",
"validates",
"and",
"sanitizes",
"a",
"policy",
"rule",
".",
"Minor",
"edits",
"such",
"as",
"capitalization",
"of",
"the",
"protocol",
"name",
"are",
"automatically",
"fixed",
"up",
".",
"More",
"fundamental",
"violations",
"will",
"cause",
"an",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/rule_validation.go#L37-L69 |
163,723 | cilium/cilium | pkg/policy/api/rule_validation.go | sanitize | func (c *CIDRRule) sanitize() (prefixLength int, err error) {
// Only allow notation <IP address>/<prefix>. Note that this differs from
// the logic in api.CIDR.Sanitize().
_, cidrNet, err := net.ParseCIDR(string(c.Cidr))
if err != nil {
return 0, fmt.Errorf("Unable to parse CIDRRule %q: %s", c.Cidr, err)
}
var bits int
prefixLength, bits = cidrNet.Mask.Size()
if prefixLength == 0 && bits == 0 {
return 0, fmt.Errorf("CIDR cannot specify non-contiguous mask %s",
cidrNet.Mask.String())
}
// Ensure that each provided exception CIDR prefix is formatted correctly,
// and is contained within the CIDR prefix to/from which we want to allow
// traffic.
for _, p := range c.ExceptCIDRs {
exceptCIDRAddr, _, err := net.ParseCIDR(string(p))
if err != nil {
return 0, err
}
// Note: this also checks that the allow CIDR prefix and the exception
// CIDR prefixes are part of the same address family.
if !cidrNet.Contains(exceptCIDRAddr) {
return 0, fmt.Errorf("allow CIDR prefix %s does not contain "+
"exclude CIDR prefix %s", c.Cidr, p)
}
}
return prefixLength, nil
} | go | func (c *CIDRRule) sanitize() (prefixLength int, err error) {
// Only allow notation <IP address>/<prefix>. Note that this differs from
// the logic in api.CIDR.Sanitize().
_, cidrNet, err := net.ParseCIDR(string(c.Cidr))
if err != nil {
return 0, fmt.Errorf("Unable to parse CIDRRule %q: %s", c.Cidr, err)
}
var bits int
prefixLength, bits = cidrNet.Mask.Size()
if prefixLength == 0 && bits == 0 {
return 0, fmt.Errorf("CIDR cannot specify non-contiguous mask %s",
cidrNet.Mask.String())
}
// Ensure that each provided exception CIDR prefix is formatted correctly,
// and is contained within the CIDR prefix to/from which we want to allow
// traffic.
for _, p := range c.ExceptCIDRs {
exceptCIDRAddr, _, err := net.ParseCIDR(string(p))
if err != nil {
return 0, err
}
// Note: this also checks that the allow CIDR prefix and the exception
// CIDR prefixes are part of the same address family.
if !cidrNet.Contains(exceptCIDRAddr) {
return 0, fmt.Errorf("allow CIDR prefix %s does not contain "+
"exclude CIDR prefix %s", c.Cidr, p)
}
}
return prefixLength, nil
} | [
"func",
"(",
"c",
"*",
"CIDRRule",
")",
"sanitize",
"(",
")",
"(",
"prefixLength",
"int",
",",
"err",
"error",
")",
"{",
"// Only allow notation <IP address>/<prefix>. Note that this differs from",
"// the logic in api.CIDR.Sanitize().",
"_",
",",
"cidrNet",
",",
"err",... | // sanitize validates a CIDRRule by checking that the CIDR prefix itself is
// valid, and ensuring that all of the exception CIDR prefixes are contained
// within the allowed CIDR prefix. | [
"sanitize",
"validates",
"a",
"CIDRRule",
"by",
"checking",
"that",
"the",
"CIDR",
"prefix",
"itself",
"is",
"valid",
"and",
"ensuring",
"that",
"all",
"of",
"the",
"exception",
"CIDR",
"prefixes",
"are",
"contained",
"within",
"the",
"allowed",
"CIDR",
"prefi... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/api/rule_validation.go#L428-L462 |
163,724 | cilium/cilium | api/v1/health/models/node_status.go | Validate | func (m *NodeStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateEndpoint(formats); err != nil {
res = append(res, err)
}
if err := m.validateHost(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *NodeStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateEndpoint(formats); err != nil {
res = append(res, err)
}
if err := m.validateHost(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"NodeStatus",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateEndpoint",
"(",
"formats",
")",
";",
"err",
"!=",
"nil"... | // Validate validates this node status | [
"Validate",
"validates",
"this",
"node",
"status"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/node_status.go#L30-L45 |
163,725 | cilium/cilium | api/v1/models/endpoint_configuration_status.go | Validate | func (m *EndpointConfigurationStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateError(formats); err != nil {
res = append(res, err)
}
if err := m.validateImmutable(formats); err != nil {
res = append(res, err)
}
if err := m.validateRealized(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *EndpointConfigurationStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateError(formats); err != nil {
res = append(res, err)
}
if err := m.validateImmutable(formats); err != nil {
res = append(res, err)
}
if err := m.validateRealized(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"EndpointConfigurationStatus",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateError",
"(",
"formats",
")",
";",
"err",
... | // Validate validates this endpoint configuration status | [
"Validate",
"validates",
"this",
"endpoint",
"configuration",
"status"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/endpoint_configuration_status.go#L30-L49 |
163,726 | cilium/cilium | api/v1/server/restapi/ipam/delete_ip_a_m_ip_responses.go | WithPayload | func (o *DeleteIPAMIPFailure) WithPayload(payload models.Error) *DeleteIPAMIPFailure {
o.Payload = payload
return o
} | go | func (o *DeleteIPAMIPFailure) WithPayload(payload models.Error) *DeleteIPAMIPFailure {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"DeleteIPAMIPFailure",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"DeleteIPAMIPFailure",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the delete Ip a m Ip failure response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"delete",
"Ip",
"a",
"m",
"Ip",
"failure",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/ipam/delete_ip_a_m_ip_responses.go#L110-L113 |
163,727 | cilium/cilium | pkg/monitor/api/types.go | DumpInfo | func (n *AgentNotify) DumpInfo() {
fmt.Printf(">> %s: %s\n", resolveAgentType(n.Type), n.Text)
} | go | func (n *AgentNotify) DumpInfo() {
fmt.Printf(">> %s: %s\n", resolveAgentType(n.Type), n.Text)
} | [
"func",
"(",
"n",
"*",
"AgentNotify",
")",
"DumpInfo",
"(",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"resolveAgentType",
"(",
"n",
".",
"Type",
")",
",",
"n",
".",
"Text",
")",
"\n",
"}"
] | // DumpInfo dumps an agent notification | [
"DumpInfo",
"dumps",
"an",
"agent",
"notification"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/api/types.go#L141-L143 |
163,728 | cilium/cilium | pkg/monitor/api/types.go | PolicyUpdateRepr | func PolicyUpdateRepr(numRules int, labels []string, revision uint64) (string, error) {
notification := PolicyUpdateNotification{
Labels: labels,
Revision: revision,
RuleCount: numRules,
}
repr, err := json.Marshal(notification)
return string(repr), err
} | go | func PolicyUpdateRepr(numRules int, labels []string, revision uint64) (string, error) {
notification := PolicyUpdateNotification{
Labels: labels,
Revision: revision,
RuleCount: numRules,
}
repr, err := json.Marshal(notification)
return string(repr), err
} | [
"func",
"PolicyUpdateRepr",
"(",
"numRules",
"int",
",",
"labels",
"[",
"]",
"string",
",",
"revision",
"uint64",
")",
"(",
"string",
",",
"error",
")",
"{",
"notification",
":=",
"PolicyUpdateNotification",
"{",
"Labels",
":",
"labels",
",",
"Revision",
":"... | // PolicyUpdateRepr returns string representation of monitor notification | [
"PolicyUpdateRepr",
"returns",
"string",
"representation",
"of",
"monitor",
"notification"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/api/types.go#L162-L172 |
163,729 | cilium/cilium | pkg/monitor/api/types.go | PolicyDeleteRepr | func PolicyDeleteRepr(deleted int, labels []string, revision uint64) (string, error) {
notification := PolicyUpdateNotification{
Labels: labels,
Revision: revision,
RuleCount: deleted,
}
repr, err := json.Marshal(notification)
return string(repr), err
} | go | func PolicyDeleteRepr(deleted int, labels []string, revision uint64) (string, error) {
notification := PolicyUpdateNotification{
Labels: labels,
Revision: revision,
RuleCount: deleted,
}
repr, err := json.Marshal(notification)
return string(repr), err
} | [
"func",
"PolicyDeleteRepr",
"(",
"deleted",
"int",
",",
"labels",
"[",
"]",
"string",
",",
"revision",
"uint64",
")",
"(",
"string",
",",
"error",
")",
"{",
"notification",
":=",
"PolicyUpdateNotification",
"{",
"Labels",
":",
"labels",
",",
"Revision",
":",... | // PolicyDeleteRepr returns string representation of monitor notification | [
"PolicyDeleteRepr",
"returns",
"string",
"representation",
"of",
"monitor",
"notification"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/api/types.go#L175-L184 |
163,730 | cilium/cilium | pkg/monitor/api/types.go | EndpointRegenRepr | func EndpointRegenRepr(e notifications.RegenNotificationInfo, err error) (string, error) {
notification := EndpointRegenNotification{
ID: e.GetID(),
Labels: e.GetOpLabels(),
}
if err != nil {
notification.Error = err.Error()
}
repr, err := json.Marshal(notification)
return string(repr), err
} | go | func EndpointRegenRepr(e notifications.RegenNotificationInfo, err error) (string, error) {
notification := EndpointRegenNotification{
ID: e.GetID(),
Labels: e.GetOpLabels(),
}
if err != nil {
notification.Error = err.Error()
}
repr, err := json.Marshal(notification)
return string(repr), err
} | [
"func",
"EndpointRegenRepr",
"(",
"e",
"notifications",
".",
"RegenNotificationInfo",
",",
"err",
"error",
")",
"(",
"string",
",",
"error",
")",
"{",
"notification",
":=",
"EndpointRegenNotification",
"{",
"ID",
":",
"e",
".",
"GetID",
"(",
")",
",",
"Label... | // EndpointRegenRepr returns string representation of monitor notification | [
"EndpointRegenRepr",
"returns",
"string",
"representation",
"of",
"monitor",
"notification"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/api/types.go#L194-L207 |
163,731 | cilium/cilium | pkg/monitor/api/types.go | TimeRepr | func TimeRepr(t time.Time) (string, error) {
notification := TimeNotification{
Time: t.String(),
}
repr, err := json.Marshal(notification)
return string(repr), err
} | go | func TimeRepr(t time.Time) (string, error) {
notification := TimeNotification{
Time: t.String(),
}
repr, err := json.Marshal(notification)
return string(repr), err
} | [
"func",
"TimeRepr",
"(",
"t",
"time",
".",
"Time",
")",
"(",
"string",
",",
"error",
")",
"{",
"notification",
":=",
"TimeNotification",
"{",
"Time",
":",
"t",
".",
"String",
"(",
")",
",",
"}",
"\n",
"repr",
",",
"err",
":=",
"json",
".",
"Marshal... | // TimeRepr returns string representation of monitor notification | [
"TimeRepr",
"returns",
"string",
"representation",
"of",
"monitor",
"notification"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/api/types.go#L215-L221 |
163,732 | cilium/cilium | pkg/envoy/xds/stream.go | NewMockStream | func NewMockStream(ctx context.Context, recvSize, sentSize int, recvTimeout, sentTimeout time.Duration) *MockStream {
return &MockStream{
ctx: ctx,
recv: make(chan *envoy_api_v2.DiscoveryRequest, recvSize),
sent: make(chan *envoy_api_v2.DiscoveryResponse, sentSize),
recvTimeout: recvTimeout,
sentTimeout: sentTimeout,
}
} | go | func NewMockStream(ctx context.Context, recvSize, sentSize int, recvTimeout, sentTimeout time.Duration) *MockStream {
return &MockStream{
ctx: ctx,
recv: make(chan *envoy_api_v2.DiscoveryRequest, recvSize),
sent: make(chan *envoy_api_v2.DiscoveryResponse, sentSize),
recvTimeout: recvTimeout,
sentTimeout: sentTimeout,
}
} | [
"func",
"NewMockStream",
"(",
"ctx",
"context",
".",
"Context",
",",
"recvSize",
",",
"sentSize",
"int",
",",
"recvTimeout",
",",
"sentTimeout",
"time",
".",
"Duration",
")",
"*",
"MockStream",
"{",
"return",
"&",
"MockStream",
"{",
"ctx",
":",
"ctx",
",",... | // NewMockStream creates a new mock Stream for testing. | [
"NewMockStream",
"creates",
"a",
"new",
"mock",
"Stream",
"for",
"testing",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/envoy/xds/stream.go#L45-L53 |
163,733 | cilium/cilium | pkg/endpoint/policy.go | LookupRedirectPort | func (e *Endpoint) LookupRedirectPort(l4Filter *policy.L4Filter) uint16 {
if !l4Filter.IsRedirect() {
return 0
}
proxyID := e.ProxyID(l4Filter)
return e.realizedRedirects[proxyID]
} | go | func (e *Endpoint) LookupRedirectPort(l4Filter *policy.L4Filter) uint16 {
if !l4Filter.IsRedirect() {
return 0
}
proxyID := e.ProxyID(l4Filter)
return e.realizedRedirects[proxyID]
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"LookupRedirectPort",
"(",
"l4Filter",
"*",
"policy",
".",
"L4Filter",
")",
"uint16",
"{",
"if",
"!",
"l4Filter",
".",
"IsRedirect",
"(",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"proxyID",
":=",
"e",
".",
"Pr... | // lookupRedirectPort returns the redirect L4 proxy port for the given L4
// policy map key, in host byte order. Returns 0 if not found or the
// filter doesn't require a redirect.
// Must be called with Endpoint.Mutex held. | [
"lookupRedirectPort",
"returns",
"the",
"redirect",
"L4",
"proxy",
"port",
"for",
"the",
"given",
"L4",
"policy",
"map",
"key",
"in",
"host",
"byte",
"order",
".",
"Returns",
"0",
"if",
"not",
"found",
"or",
"the",
"filter",
"doesn",
"t",
"require",
"a",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L58-L64 |
163,734 | cilium/cilium | pkg/endpoint/policy.go | updateNetworkPolicy | func (e *Endpoint) updateNetworkPolicy(owner Owner, proxyWaitGroup *completion.WaitGroup) (reterr error, revertFunc revert.RevertFunc) {
// Skip updating the NetworkPolicy if no identity has been computed for this
// endpoint.
// This breaks a circular dependency between configuring NetworkPolicies in
// sidecar Envoy proxies and those proxies needing network connectivity
// to get their initial configuration, which is required for them to ACK
// the NetworkPolicies.
if e.SecurityIdentity == nil {
return nil, nil
}
// Publish the updated policy to L7 proxies.
var desiredL4Policy *policy.L4Policy
if e.desiredPolicy != nil {
desiredL4Policy = e.desiredPolicy.L4Policy
}
return owner.UpdateNetworkPolicy(e, desiredL4Policy, *e.prevIdentityCache, e.desiredPolicy.DeniedIngressIdentities, e.desiredPolicy.DeniedEgressIdentities, proxyWaitGroup)
} | go | func (e *Endpoint) updateNetworkPolicy(owner Owner, proxyWaitGroup *completion.WaitGroup) (reterr error, revertFunc revert.RevertFunc) {
// Skip updating the NetworkPolicy if no identity has been computed for this
// endpoint.
// This breaks a circular dependency between configuring NetworkPolicies in
// sidecar Envoy proxies and those proxies needing network connectivity
// to get their initial configuration, which is required for them to ACK
// the NetworkPolicies.
if e.SecurityIdentity == nil {
return nil, nil
}
// Publish the updated policy to L7 proxies.
var desiredL4Policy *policy.L4Policy
if e.desiredPolicy != nil {
desiredL4Policy = e.desiredPolicy.L4Policy
}
return owner.UpdateNetworkPolicy(e, desiredL4Policy, *e.prevIdentityCache, e.desiredPolicy.DeniedIngressIdentities, e.desiredPolicy.DeniedEgressIdentities, proxyWaitGroup)
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"updateNetworkPolicy",
"(",
"owner",
"Owner",
",",
"proxyWaitGroup",
"*",
"completion",
".",
"WaitGroup",
")",
"(",
"reterr",
"error",
",",
"revertFunc",
"revert",
".",
"RevertFunc",
")",
"{",
"// Skip updating the Network... | // Note that this function assumes that endpoint policy has already been generated!
// must be called with endpoint.Mutex held for reading | [
"Note",
"that",
"this",
"function",
"assumes",
"that",
"endpoint",
"policy",
"has",
"already",
"been",
"generated!",
"must",
"be",
"called",
"with",
"endpoint",
".",
"Mutex",
"held",
"for",
"reading"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L68-L85 |
163,735 | cilium/cilium | pkg/endpoint/policy.go | setNextPolicyRevision | func (e *Endpoint) setNextPolicyRevision(revision uint64) {
e.nextPolicyRevision = revision
e.UpdateLogger(map[string]interface{}{
logfields.DesiredPolicyRevision: e.nextPolicyRevision,
})
} | go | func (e *Endpoint) setNextPolicyRevision(revision uint64) {
e.nextPolicyRevision = revision
e.UpdateLogger(map[string]interface{}{
logfields.DesiredPolicyRevision: e.nextPolicyRevision,
})
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"setNextPolicyRevision",
"(",
"revision",
"uint64",
")",
"{",
"e",
".",
"nextPolicyRevision",
"=",
"revision",
"\n",
"e",
".",
"UpdateLogger",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"logfields",
... | // setNextPolicyRevision updates the desired policy revision field
// Must be called with the endpoint lock held for at least reading | [
"setNextPolicyRevision",
"updates",
"the",
"desired",
"policy",
"revision",
"field",
"Must",
"be",
"called",
"with",
"the",
"endpoint",
"lock",
"held",
"for",
"at",
"least",
"reading"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L89-L94 |
163,736 | cilium/cilium | pkg/endpoint/policy.go | updateAndOverrideEndpointOptions | func (e *Endpoint) updateAndOverrideEndpointOptions(opts option.OptionMap) (optsChanged bool) {
if opts == nil {
opts = make(option.OptionMap)
}
// Apply possible option changes before regenerating maps, as map regeneration
// depends on the conntrack options
if e.desiredPolicy != nil && e.desiredPolicy.L4Policy != nil {
if e.desiredPolicy.L4Policy.RequiresConntrack() {
opts[option.Conntrack] = option.OptionEnabled
}
}
optsChanged = e.applyOptsLocked(opts)
return
} | go | func (e *Endpoint) updateAndOverrideEndpointOptions(opts option.OptionMap) (optsChanged bool) {
if opts == nil {
opts = make(option.OptionMap)
}
// Apply possible option changes before regenerating maps, as map regeneration
// depends on the conntrack options
if e.desiredPolicy != nil && e.desiredPolicy.L4Policy != nil {
if e.desiredPolicy.L4Policy.RequiresConntrack() {
opts[option.Conntrack] = option.OptionEnabled
}
}
optsChanged = e.applyOptsLocked(opts)
return
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"updateAndOverrideEndpointOptions",
"(",
"opts",
"option",
".",
"OptionMap",
")",
"(",
"optsChanged",
"bool",
")",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"make",
"(",
"option",
".",
"OptionMap",
")",
"\n... | // updateAndOverrideEndpointOptions updates the boolean configuration options for the endpoint
// based off of policy configuration, daemon policy enforcement mode, and any
// configuration options provided in opts. Returns whether the options changed
// from prior endpoint configuration. Note that the policy which applies
// to the endpoint, as well as the daemon's policy enforcement, may override
// configuration changes which were made via the API that were provided in opts.
// Must be called with endpoint mutex held. | [
"updateAndOverrideEndpointOptions",
"updates",
"the",
"boolean",
"configuration",
"options",
"for",
"the",
"endpoint",
"based",
"off",
"of",
"policy",
"configuration",
"daemon",
"policy",
"enforcement",
"mode",
"and",
"any",
"configuration",
"options",
"provided",
"in",... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L234-L248 |
163,737 | cilium/cilium | pkg/endpoint/policy.go | updateRealizedState | func (e *Endpoint) updateRealizedState(stats *regenerationStatistics, origDir string, revision uint64, compilationExecuted bool) error {
// Update desired policy for endpoint because policy has now been realized
// in the datapath. PolicyMap state is not updated here, because that is
// performed in endpoint.syncPolicyMap().
stats.waitingForLock.Start()
err := e.LockAlive()
stats.waitingForLock.End(err == nil)
if err != nil {
return err
}
defer e.Unlock()
// Depending upon result of BPF regeneration (compilation executed),
// shift endpoint directories to match said BPF regeneration
// results.
err = e.synchronizeDirectories(origDir, compilationExecuted)
if err != nil {
return fmt.Errorf("error synchronizing endpoint BPF program directories: %s", err)
}
// Keep PolicyMap for this endpoint in sync with desired / realized state.
if !option.Config.DryMode {
e.syncPolicyMapController()
}
e.realizedBPFConfig = e.desiredBPFConfig
// Set realized state to desired state fields.
e.realizedPolicy.Realizes(e.desiredPolicy)
// Mark the endpoint to be running the policy revision it was
// compiled for
e.setPolicyRevision(revision)
return nil
} | go | func (e *Endpoint) updateRealizedState(stats *regenerationStatistics, origDir string, revision uint64, compilationExecuted bool) error {
// Update desired policy for endpoint because policy has now been realized
// in the datapath. PolicyMap state is not updated here, because that is
// performed in endpoint.syncPolicyMap().
stats.waitingForLock.Start()
err := e.LockAlive()
stats.waitingForLock.End(err == nil)
if err != nil {
return err
}
defer e.Unlock()
// Depending upon result of BPF regeneration (compilation executed),
// shift endpoint directories to match said BPF regeneration
// results.
err = e.synchronizeDirectories(origDir, compilationExecuted)
if err != nil {
return fmt.Errorf("error synchronizing endpoint BPF program directories: %s", err)
}
// Keep PolicyMap for this endpoint in sync with desired / realized state.
if !option.Config.DryMode {
e.syncPolicyMapController()
}
e.realizedBPFConfig = e.desiredBPFConfig
// Set realized state to desired state fields.
e.realizedPolicy.Realizes(e.desiredPolicy)
// Mark the endpoint to be running the policy revision it was
// compiled for
e.setPolicyRevision(revision)
return nil
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"updateRealizedState",
"(",
"stats",
"*",
"regenerationStatistics",
",",
"origDir",
"string",
",",
"revision",
"uint64",
",",
"compilationExecuted",
"bool",
")",
"error",
"{",
"// Update desired policy for endpoint because policy ... | // updateRealizedState sets any realized state fields within the endpoint to
// be the desired state of the endpoint. This is only called after a successful
// regeneration of the endpoint. | [
"updateRealizedState",
"sets",
"any",
"realized",
"state",
"fields",
"within",
"the",
"endpoint",
"to",
"be",
"the",
"desired",
"state",
"of",
"the",
"endpoint",
".",
"This",
"is",
"only",
"called",
"after",
"a",
"successful",
"regeneration",
"of",
"the",
"end... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L360-L396 |
163,738 | cilium/cilium | pkg/endpoint/policy.go | Regenerate | func (e *Endpoint) Regenerate(owner Owner, regenMetadata *ExternalRegenerationMetadata) <-chan bool {
done := make(chan bool, 1)
var (
ctx context.Context
cFunc context.CancelFunc
)
if regenMetadata.ParentContext != nil {
ctx, cFunc = context.WithCancel(regenMetadata.ParentContext)
} else {
ctx, cFunc = context.WithCancel(context.Background())
}
regenContext := regenMetadata.toRegenerationContext(ctx, cFunc)
epEvent := eventqueue.NewEvent(&EndpointRegenerationEvent{
owner: owner,
regenContext: regenContext,
ep: e,
})
// This may block if the Endpoint's EventQueue is full. This has to be done
// synchronously as some callers depend on the fact that the event is
// synchronously enqueued.
resChan := e.EventQueue.Enqueue(epEvent)
go func() {
// Free up resources with context.
defer cFunc()
var buildSuccess bool
var regenError error
select {
case result, ok := <-resChan:
if ok {
regenResult := result.(*EndpointRegenerationResult)
regenError = regenResult.err
buildSuccess = regenError == nil
} else {
// This may be unnecessary(?) since 'closing' of the results
// channel means that event has been cancelled?
e.getLogger().Debug("regeneration was cancelled")
}
}
done <- buildSuccess
close(done)
}()
return done
} | go | func (e *Endpoint) Regenerate(owner Owner, regenMetadata *ExternalRegenerationMetadata) <-chan bool {
done := make(chan bool, 1)
var (
ctx context.Context
cFunc context.CancelFunc
)
if regenMetadata.ParentContext != nil {
ctx, cFunc = context.WithCancel(regenMetadata.ParentContext)
} else {
ctx, cFunc = context.WithCancel(context.Background())
}
regenContext := regenMetadata.toRegenerationContext(ctx, cFunc)
epEvent := eventqueue.NewEvent(&EndpointRegenerationEvent{
owner: owner,
regenContext: regenContext,
ep: e,
})
// This may block if the Endpoint's EventQueue is full. This has to be done
// synchronously as some callers depend on the fact that the event is
// synchronously enqueued.
resChan := e.EventQueue.Enqueue(epEvent)
go func() {
// Free up resources with context.
defer cFunc()
var buildSuccess bool
var regenError error
select {
case result, ok := <-resChan:
if ok {
regenResult := result.(*EndpointRegenerationResult)
regenError = regenResult.err
buildSuccess = regenError == nil
} else {
// This may be unnecessary(?) since 'closing' of the results
// channel means that event has been cancelled?
e.getLogger().Debug("regeneration was cancelled")
}
}
done <- buildSuccess
close(done)
}()
return done
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"Regenerate",
"(",
"owner",
"Owner",
",",
"regenMetadata",
"*",
"ExternalRegenerationMetadata",
")",
"<-",
"chan",
"bool",
"{",
"done",
":=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n\n",
"var",
"(",
"ctx",
... | // Regenerate forces the regeneration of endpoint programs & policy
// Should only be called with e.state == StateWaitingToRegenerate or with
// e.state == StateWaitingForIdentity | [
"Regenerate",
"forces",
"the",
"regeneration",
"of",
"endpoint",
"programs",
"&",
"policy",
"Should",
"only",
"be",
"called",
"with",
"e",
".",
"state",
"==",
"StateWaitingToRegenerate",
"or",
"with",
"e",
".",
"state",
"==",
"StateWaitingForIdentity"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L441-L494 |
163,739 | cilium/cilium | pkg/endpoint/policy.go | runIPIdentitySync | func (e *Endpoint) runIPIdentitySync(endpointIP addressing.CiliumIP) {
if !endpointIP.IsSet() {
return
}
addressFamily := endpointIP.GetFamilyString()
e.controllers.UpdateController(fmt.Sprintf("sync-%s-identity-mapping (%d)", addressFamily, e.ID),
controller.ControllerParams{
DoFunc: func(ctx context.Context) error {
if err := e.RLockAlive(); err != nil {
return controller.NewExitReason("Endpoint disappeared")
}
if e.SecurityIdentity == nil {
e.RUnlock()
return nil
}
IP := endpointIP.IP()
ID := e.SecurityIdentity.ID
hostIP := node.GetExternalIPv4()
key := node.GetIPsecKeyIdentity()
metadata := e.FormatGlobalEndpointID()
// Release lock as we do not want to have long-lasting key-value
// store operations resulting in lock being held for a long time.
e.RUnlock()
if err := ipcache.UpsertIPToKVStore(ctx, IP, hostIP, ID, key, metadata); err != nil {
return fmt.Errorf("unable to add endpoint IP mapping '%s'->'%d': %s", IP.String(), ID, err)
}
return nil
},
StopFunc: func(ctx context.Context) error {
ip := endpointIP.String()
if err := ipcache.DeleteIPFromKVStore(ctx, ip); err != nil {
return fmt.Errorf("unable to delete endpoint IP '%s' from ipcache: %s", ip, err)
}
return nil
},
RunInterval: 5 * time.Minute,
},
)
} | go | func (e *Endpoint) runIPIdentitySync(endpointIP addressing.CiliumIP) {
if !endpointIP.IsSet() {
return
}
addressFamily := endpointIP.GetFamilyString()
e.controllers.UpdateController(fmt.Sprintf("sync-%s-identity-mapping (%d)", addressFamily, e.ID),
controller.ControllerParams{
DoFunc: func(ctx context.Context) error {
if err := e.RLockAlive(); err != nil {
return controller.NewExitReason("Endpoint disappeared")
}
if e.SecurityIdentity == nil {
e.RUnlock()
return nil
}
IP := endpointIP.IP()
ID := e.SecurityIdentity.ID
hostIP := node.GetExternalIPv4()
key := node.GetIPsecKeyIdentity()
metadata := e.FormatGlobalEndpointID()
// Release lock as we do not want to have long-lasting key-value
// store operations resulting in lock being held for a long time.
e.RUnlock()
if err := ipcache.UpsertIPToKVStore(ctx, IP, hostIP, ID, key, metadata); err != nil {
return fmt.Errorf("unable to add endpoint IP mapping '%s'->'%d': %s", IP.String(), ID, err)
}
return nil
},
StopFunc: func(ctx context.Context) error {
ip := endpointIP.String()
if err := ipcache.DeleteIPFromKVStore(ctx, ip); err != nil {
return fmt.Errorf("unable to delete endpoint IP '%s' from ipcache: %s", ip, err)
}
return nil
},
RunInterval: 5 * time.Minute,
},
)
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"runIPIdentitySync",
"(",
"endpointIP",
"addressing",
".",
"CiliumIP",
")",
"{",
"if",
"!",
"endpointIP",
".",
"IsSet",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"addressFamily",
":=",
"endpointIP",
".",
"GetFamily... | // This synchronizes the key-value store with a mapping of the endpoint's IP
// with the numerical ID representing its security identity. | [
"This",
"synchronizes",
"the",
"key",
"-",
"value",
"store",
"with",
"a",
"mapping",
"of",
"the",
"endpoint",
"s",
"IP",
"with",
"the",
"numerical",
"ID",
"representing",
"its",
"security",
"identity",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L523-L568 |
163,740 | cilium/cilium | pkg/endpoint/policy.go | SetIdentity | func (e *Endpoint) SetIdentity(identity *identityPkg.Identity) {
// Set a boolean flag to indicate whether the endpoint has been injected by
// Istio with a Cilium-compatible sidecar proxy.
istioSidecarProxyLabel, found := identity.Labels[k8sConst.PolicyLabelIstioSidecarProxy]
e.hasSidecarProxy = found &&
istioSidecarProxyLabel.Source == labels.LabelSourceK8s &&
strings.ToLower(istioSidecarProxyLabel.Value) == "true"
oldIdentity := "no identity"
if e.SecurityIdentity != nil {
oldIdentity = e.SecurityIdentity.StringID()
}
// Current security identity for endpoint is its old identity - delete its
// reference from global identity manager, add add a reference to the new
// identity for the endpoint.
identitymanager.RemoveOldAddNew(e.SecurityIdentity, identity)
e.SecurityIdentity = identity
// Clear selectorPolicy. It will be determined at next regeneration.
e.selectorPolicy = nil
// Sets endpoint state to ready if was waiting for identity
if e.GetStateLocked() == StateWaitingForIdentity {
e.SetStateLocked(StateReady, "Set identity for this endpoint")
}
// Whenever the identity is updated, propagate change to key-value store
// of IP to identity mapping.
e.runIPIdentitySync(e.IPv4)
e.runIPIdentitySync(e.IPv6)
if oldIdentity != identity.StringID() {
e.getLogger().WithFields(logrus.Fields{
logfields.Identity: identity.StringID(),
logfields.OldIdentity: oldIdentity,
logfields.IdentityLabels: identity.Labels.String(),
}).Info("Identity of endpoint changed")
}
e.UpdateLogger(map[string]interface{}{
logfields.Identity: identity.StringID(),
})
} | go | func (e *Endpoint) SetIdentity(identity *identityPkg.Identity) {
// Set a boolean flag to indicate whether the endpoint has been injected by
// Istio with a Cilium-compatible sidecar proxy.
istioSidecarProxyLabel, found := identity.Labels[k8sConst.PolicyLabelIstioSidecarProxy]
e.hasSidecarProxy = found &&
istioSidecarProxyLabel.Source == labels.LabelSourceK8s &&
strings.ToLower(istioSidecarProxyLabel.Value) == "true"
oldIdentity := "no identity"
if e.SecurityIdentity != nil {
oldIdentity = e.SecurityIdentity.StringID()
}
// Current security identity for endpoint is its old identity - delete its
// reference from global identity manager, add add a reference to the new
// identity for the endpoint.
identitymanager.RemoveOldAddNew(e.SecurityIdentity, identity)
e.SecurityIdentity = identity
// Clear selectorPolicy. It will be determined at next regeneration.
e.selectorPolicy = nil
// Sets endpoint state to ready if was waiting for identity
if e.GetStateLocked() == StateWaitingForIdentity {
e.SetStateLocked(StateReady, "Set identity for this endpoint")
}
// Whenever the identity is updated, propagate change to key-value store
// of IP to identity mapping.
e.runIPIdentitySync(e.IPv4)
e.runIPIdentitySync(e.IPv6)
if oldIdentity != identity.StringID() {
e.getLogger().WithFields(logrus.Fields{
logfields.Identity: identity.StringID(),
logfields.OldIdentity: oldIdentity,
logfields.IdentityLabels: identity.Labels.String(),
}).Info("Identity of endpoint changed")
}
e.UpdateLogger(map[string]interface{}{
logfields.Identity: identity.StringID(),
})
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"SetIdentity",
"(",
"identity",
"*",
"identityPkg",
".",
"Identity",
")",
"{",
"// Set a boolean flag to indicate whether the endpoint has been injected by",
"// Istio with a Cilium-compatible sidecar proxy.",
"istioSidecarProxyLabel",
",",... | // SetIdentity resets endpoint's policy identity to 'id'.
// Caller triggers policy regeneration if needed.
// Called with e.Mutex Locked | [
"SetIdentity",
"resets",
"endpoint",
"s",
"policy",
"identity",
"to",
"id",
".",
"Caller",
"triggers",
"policy",
"regeneration",
"if",
"needed",
".",
"Called",
"with",
"e",
".",
"Mutex",
"Locked"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L573-L616 |
163,741 | cilium/cilium | pkg/endpoint/policy.go | GetCIDRPrefixLengths | func (e *Endpoint) GetCIDRPrefixLengths() (s6, s4 []int) {
if e.desiredPolicy == nil || e.desiredPolicy.CIDRPolicy == nil {
return policy.GetDefaultPrefixLengths()
}
return e.desiredPolicy.CIDRPolicy.ToBPFData()
} | go | func (e *Endpoint) GetCIDRPrefixLengths() (s6, s4 []int) {
if e.desiredPolicy == nil || e.desiredPolicy.CIDRPolicy == nil {
return policy.GetDefaultPrefixLengths()
}
return e.desiredPolicy.CIDRPolicy.ToBPFData()
} | [
"func",
"(",
"e",
"*",
"Endpoint",
")",
"GetCIDRPrefixLengths",
"(",
")",
"(",
"s6",
",",
"s4",
"[",
"]",
"int",
")",
"{",
"if",
"e",
".",
"desiredPolicy",
"==",
"nil",
"||",
"e",
".",
"desiredPolicy",
".",
"CIDRPolicy",
"==",
"nil",
"{",
"return",
... | // GetCIDRPrefixLengths returns the sorted list of unique prefix lengths used
// for CIDR policy or IPcache lookup from this endpoint. | [
"GetCIDRPrefixLengths",
"returns",
"the",
"sorted",
"list",
"of",
"unique",
"prefix",
"lengths",
"used",
"for",
"CIDR",
"policy",
"or",
"IPcache",
"lookup",
"from",
"this",
"endpoint",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/endpoint/policy.go#L620-L625 |
163,742 | cilium/cilium | pkg/nodediscovery/nodediscovery.go | NewNodeDiscovery | func NewNodeDiscovery(manager *nodemanager.Manager, mtuConfig mtu.Configuration) *NodeDiscovery {
auxPrefixes := []*cidr.CIDR{}
if option.Config.IPv4ServiceRange != AutoCIDR {
serviceCIDR, err := cidr.ParseCIDR(option.Config.IPv4ServiceRange)
if err != nil {
log.WithError(err).WithField(logfields.V4Prefix, option.Config.IPv4ServiceRange).Fatal("Invalid IPv4 service prefix")
}
auxPrefixes = append(auxPrefixes, serviceCIDR)
}
if option.Config.IPv6ServiceRange != AutoCIDR {
serviceCIDR, err := cidr.ParseCIDR(option.Config.IPv6ServiceRange)
if err != nil {
log.WithError(err).WithField(logfields.V6Prefix, option.Config.IPv6ServiceRange).Fatal("Invalid IPv6 service prefix")
}
auxPrefixes = append(auxPrefixes, serviceCIDR)
}
return &NodeDiscovery{
Manager: manager,
LocalConfig: datapath.LocalNodeConfiguration{
MtuConfig: mtuConfig,
UseSingleClusterRoute: option.Config.UseSingleClusterRoute,
EnableIPv4: option.Config.EnableIPv4,
EnableIPv6: option.Config.EnableIPv6,
EnableEncapsulation: option.Config.Tunnel != option.TunnelDisabled,
EnableAutoDirectRouting: option.Config.EnableAutoDirectRouting,
EnableLocalNodeRoute: enableLocalNodeRoute(),
AuxiliaryPrefixes: auxPrefixes,
EnableIPSec: option.Config.EnableIPSec,
},
LocalNode: node.Node{
Source: node.FromLocalNode,
},
Registered: make(chan struct{}),
}
} | go | func NewNodeDiscovery(manager *nodemanager.Manager, mtuConfig mtu.Configuration) *NodeDiscovery {
auxPrefixes := []*cidr.CIDR{}
if option.Config.IPv4ServiceRange != AutoCIDR {
serviceCIDR, err := cidr.ParseCIDR(option.Config.IPv4ServiceRange)
if err != nil {
log.WithError(err).WithField(logfields.V4Prefix, option.Config.IPv4ServiceRange).Fatal("Invalid IPv4 service prefix")
}
auxPrefixes = append(auxPrefixes, serviceCIDR)
}
if option.Config.IPv6ServiceRange != AutoCIDR {
serviceCIDR, err := cidr.ParseCIDR(option.Config.IPv6ServiceRange)
if err != nil {
log.WithError(err).WithField(logfields.V6Prefix, option.Config.IPv6ServiceRange).Fatal("Invalid IPv6 service prefix")
}
auxPrefixes = append(auxPrefixes, serviceCIDR)
}
return &NodeDiscovery{
Manager: manager,
LocalConfig: datapath.LocalNodeConfiguration{
MtuConfig: mtuConfig,
UseSingleClusterRoute: option.Config.UseSingleClusterRoute,
EnableIPv4: option.Config.EnableIPv4,
EnableIPv6: option.Config.EnableIPv6,
EnableEncapsulation: option.Config.Tunnel != option.TunnelDisabled,
EnableAutoDirectRouting: option.Config.EnableAutoDirectRouting,
EnableLocalNodeRoute: enableLocalNodeRoute(),
AuxiliaryPrefixes: auxPrefixes,
EnableIPSec: option.Config.EnableIPSec,
},
LocalNode: node.Node{
Source: node.FromLocalNode,
},
Registered: make(chan struct{}),
}
} | [
"func",
"NewNodeDiscovery",
"(",
"manager",
"*",
"nodemanager",
".",
"Manager",
",",
"mtuConfig",
"mtu",
".",
"Configuration",
")",
"*",
"NodeDiscovery",
"{",
"auxPrefixes",
":=",
"[",
"]",
"*",
"cidr",
".",
"CIDR",
"{",
"}",
"\n\n",
"if",
"option",
".",
... | // NewNodeDiscovery returns a pointer to new node discovery object | [
"NewNodeDiscovery",
"returns",
"a",
"pointer",
"to",
"new",
"node",
"discovery",
"object"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/nodediscovery/nodediscovery.go#L62-L101 |
163,743 | cilium/cilium | pkg/nodediscovery/nodediscovery.go | StartDiscovery | func (n *NodeDiscovery) StartDiscovery(nodeName string) {
n.LocalNode.Name = nodeName
n.LocalNode.Cluster = option.Config.ClusterName
n.LocalNode.IPAddresses = []node.Address{}
n.LocalNode.IPv4AllocCIDR = node.GetIPv4AllocRange()
n.LocalNode.IPv6AllocCIDR = node.GetIPv6AllocRange()
n.LocalNode.ClusterID = option.Config.ClusterID
n.LocalNode.EncryptionKey = node.GetIPsecKeyIdentity()
if node.GetExternalIPv4() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeInternalIP,
IP: node.GetExternalIPv4(),
})
}
if node.GetIPv6() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeInternalIP,
IP: node.GetIPv6(),
})
}
if node.GetInternalIPv4() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeCiliumInternalIP,
IP: node.GetInternalIPv4(),
})
}
if node.GetIPv6Router() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeCiliumInternalIP,
IP: node.GetIPv6Router(),
})
}
n.Manager.NodeUpdated(n.LocalNode)
go func() {
log.Info("Adding local node to cluster")
for {
if err := n.Registrar.RegisterNode(&n.LocalNode, n.Manager); err != nil {
log.WithError(err).Error("Unable to initialize local node. Retrying...")
time.Sleep(time.Second)
} else {
break
}
}
close(n.Registered)
}()
go func() {
select {
case <-n.Registered:
case <-time.NewTimer(defaults.NodeInitTimeout).C:
log.Fatalf("Unable to initialize local node due to timeout")
}
}()
go func() {
<-n.Registered
controller.NewManager().UpdateController("propagating local node change to kv-store",
controller.ControllerParams{
DoFunc: func(ctx context.Context) error {
err := n.Registrar.UpdateLocalKeySync(&n.LocalNode)
if err != nil {
log.WithError(err).Error("Unable to propagate local node change to kvstore")
}
return err
},
})
}()
} | go | func (n *NodeDiscovery) StartDiscovery(nodeName string) {
n.LocalNode.Name = nodeName
n.LocalNode.Cluster = option.Config.ClusterName
n.LocalNode.IPAddresses = []node.Address{}
n.LocalNode.IPv4AllocCIDR = node.GetIPv4AllocRange()
n.LocalNode.IPv6AllocCIDR = node.GetIPv6AllocRange()
n.LocalNode.ClusterID = option.Config.ClusterID
n.LocalNode.EncryptionKey = node.GetIPsecKeyIdentity()
if node.GetExternalIPv4() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeInternalIP,
IP: node.GetExternalIPv4(),
})
}
if node.GetIPv6() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeInternalIP,
IP: node.GetIPv6(),
})
}
if node.GetInternalIPv4() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeCiliumInternalIP,
IP: node.GetInternalIPv4(),
})
}
if node.GetIPv6Router() != nil {
n.LocalNode.IPAddresses = append(n.LocalNode.IPAddresses, node.Address{
Type: addressing.NodeCiliumInternalIP,
IP: node.GetIPv6Router(),
})
}
n.Manager.NodeUpdated(n.LocalNode)
go func() {
log.Info("Adding local node to cluster")
for {
if err := n.Registrar.RegisterNode(&n.LocalNode, n.Manager); err != nil {
log.WithError(err).Error("Unable to initialize local node. Retrying...")
time.Sleep(time.Second)
} else {
break
}
}
close(n.Registered)
}()
go func() {
select {
case <-n.Registered:
case <-time.NewTimer(defaults.NodeInitTimeout).C:
log.Fatalf("Unable to initialize local node due to timeout")
}
}()
go func() {
<-n.Registered
controller.NewManager().UpdateController("propagating local node change to kv-store",
controller.ControllerParams{
DoFunc: func(ctx context.Context) error {
err := n.Registrar.UpdateLocalKeySync(&n.LocalNode)
if err != nil {
log.WithError(err).Error("Unable to propagate local node change to kvstore")
}
return err
},
})
}()
} | [
"func",
"(",
"n",
"*",
"NodeDiscovery",
")",
"StartDiscovery",
"(",
"nodeName",
"string",
")",
"{",
"n",
".",
"LocalNode",
".",
"Name",
"=",
"nodeName",
"\n",
"n",
".",
"LocalNode",
".",
"Cluster",
"=",
"option",
".",
"Config",
".",
"ClusterName",
"\n",
... | // start configures the local node and starts node discovery. This is called on
// agent startup to configure the local node based on the configuration options
// passed to the agent. nodeName is the name to be used in the local agent. | [
"start",
"configures",
"the",
"local",
"node",
"and",
"starts",
"node",
"discovery",
".",
"This",
"is",
"called",
"on",
"agent",
"startup",
"to",
"configure",
"the",
"local",
"node",
"based",
"on",
"the",
"configuration",
"options",
"passed",
"to",
"the",
"a... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/nodediscovery/nodediscovery.go#L106-L179 |
163,744 | cilium/cilium | pkg/logging/logging.go | InitializeDefaultLogger | func InitializeDefaultLogger() *logrus.Logger {
logger := logrus.New()
logger.Formatter = setupFormatter()
return logger
} | go | func InitializeDefaultLogger() *logrus.Logger {
logger := logrus.New()
logger.Formatter = setupFormatter()
return logger
} | [
"func",
"InitializeDefaultLogger",
"(",
")",
"*",
"logrus",
".",
"Logger",
"{",
"logger",
":=",
"logrus",
".",
"New",
"(",
")",
"\n",
"logger",
".",
"Formatter",
"=",
"setupFormatter",
"(",
")",
"\n",
"return",
"logger",
"\n",
"}"
] | // InitializeDefaultLogger returns a logrus Logger with a custom text formatter. | [
"InitializeDefaultLogger",
"returns",
"a",
"logrus",
"Logger",
"with",
"a",
"custom",
"text",
"formatter",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L62-L66 |
163,745 | cilium/cilium | pkg/logging/logging.go | SetupLogging | func SetupLogging(loggers []string, logOpts map[string]string, tag string, debug bool) error {
// Set default logger to output to stdout if no loggers are provided.
if len(loggers) == 0 {
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
logrus.SetOutput(os.Stdout)
}
SetLogLevel(DefaultLogLevel)
ToggleDebugLogs(debug)
// always suppress the default logger so libraries don't print things
logrus.SetLevel(logrus.PanicLevel)
// Iterate through all provided loggers and configure them according
// to user-provided settings.
for _, logger := range loggers {
switch logger {
case Syslog:
valuesToValidate := getLogDriverConfig(Syslog, logOpts)
err := validateOpts(Syslog, valuesToValidate, syslogOpts)
if err != nil {
return err
}
setupSyslog(valuesToValidate, tag, debug)
default:
return fmt.Errorf("provided log driver %q is not a supported log driver", logger)
}
}
return nil
} | go | func SetupLogging(loggers []string, logOpts map[string]string, tag string, debug bool) error {
// Set default logger to output to stdout if no loggers are provided.
if len(loggers) == 0 {
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
logrus.SetOutput(os.Stdout)
}
SetLogLevel(DefaultLogLevel)
ToggleDebugLogs(debug)
// always suppress the default logger so libraries don't print things
logrus.SetLevel(logrus.PanicLevel)
// Iterate through all provided loggers and configure them according
// to user-provided settings.
for _, logger := range loggers {
switch logger {
case Syslog:
valuesToValidate := getLogDriverConfig(Syslog, logOpts)
err := validateOpts(Syslog, valuesToValidate, syslogOpts)
if err != nil {
return err
}
setupSyslog(valuesToValidate, tag, debug)
default:
return fmt.Errorf("provided log driver %q is not a supported log driver", logger)
}
}
return nil
} | [
"func",
"SetupLogging",
"(",
"loggers",
"[",
"]",
"string",
",",
"logOpts",
"map",
"[",
"string",
"]",
"string",
",",
"tag",
"string",
",",
"debug",
"bool",
")",
"error",
"{",
"// Set default logger to output to stdout if no loggers are provided.",
"if",
"len",
"(... | // SetupLogging sets up each logging service provided in loggers and configures
// each logger with the provided logOpts. | [
"SetupLogging",
"sets",
"up",
"each",
"logging",
"service",
"provided",
"in",
"loggers",
"and",
"configures",
"each",
"logger",
"with",
"the",
"provided",
"logOpts",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L70-L100 |
163,746 | cilium/cilium | pkg/logging/logging.go | setupSyslog | func setupSyslog(logOpts map[string]string, tag string, debug bool) {
logLevel, ok := logOpts[SLevel]
if !ok {
if debug {
logLevel = "debug"
} else {
logLevel = "info"
}
}
//Validate provided log level.
level, err := logrus.ParseLevel(logLevel)
if err != nil {
DefaultLogger.Fatal(err)
}
DefaultLogger.SetLevel(level)
// Create syslog hook.
h, err := logrus_syslog.NewSyslogHook("", "", syslogLevelMap[level], tag)
if err != nil {
DefaultLogger.Fatal(err)
}
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
logrus.AddHook(h)
} | go | func setupSyslog(logOpts map[string]string, tag string, debug bool) {
logLevel, ok := logOpts[SLevel]
if !ok {
if debug {
logLevel = "debug"
} else {
logLevel = "info"
}
}
//Validate provided log level.
level, err := logrus.ParseLevel(logLevel)
if err != nil {
DefaultLogger.Fatal(err)
}
DefaultLogger.SetLevel(level)
// Create syslog hook.
h, err := logrus_syslog.NewSyslogHook("", "", syslogLevelMap[level], tag)
if err != nil {
DefaultLogger.Fatal(err)
}
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
logrus.AddHook(h)
} | [
"func",
"setupSyslog",
"(",
"logOpts",
"map",
"[",
"string",
"]",
"string",
",",
"tag",
"string",
",",
"debug",
"bool",
")",
"{",
"logLevel",
",",
"ok",
":=",
"logOpts",
"[",
"SLevel",
"]",
"\n",
"if",
"!",
"ok",
"{",
"if",
"debug",
"{",
"logLevel",
... | // setupSyslog sets up and configures syslog with the provided options in
// logOpts. If some options are not provided, sensible defaults are used. | [
"setupSyslog",
"sets",
"up",
"and",
"configures",
"syslog",
"with",
"the",
"provided",
"options",
"in",
"logOpts",
".",
"If",
"some",
"options",
"are",
"not",
"provided",
"sensible",
"defaults",
"are",
"used",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L124-L148 |
163,747 | cilium/cilium | pkg/logging/logging.go | setupFormatter | func setupFormatter() logrus.Formatter {
fileFormat := new(logrus.TextFormatter)
fileFormat.DisableTimestamp = true
fileFormat.DisableColors = true
switch os.Getenv("INITSYSTEM") {
case "SYSTEMD":
fileFormat.FullTimestamp = true
default:
fileFormat.TimestampFormat = time.RFC3339
}
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
return fileFormat
} | go | func setupFormatter() logrus.Formatter {
fileFormat := new(logrus.TextFormatter)
fileFormat.DisableTimestamp = true
fileFormat.DisableColors = true
switch os.Getenv("INITSYSTEM") {
case "SYSTEMD":
fileFormat.FullTimestamp = true
default:
fileFormat.TimestampFormat = time.RFC3339
}
// TODO: switch to a per-logger version when we upgrade to logrus >1.0.3
return fileFormat
} | [
"func",
"setupFormatter",
"(",
")",
"logrus",
".",
"Formatter",
"{",
"fileFormat",
":=",
"new",
"(",
"logrus",
".",
"TextFormatter",
")",
"\n",
"fileFormat",
".",
"DisableTimestamp",
"=",
"true",
"\n",
"fileFormat",
".",
"DisableColors",
"=",
"true",
"\n",
"... | // setupFormatter sets up the text formatting for logs output by logrus. | [
"setupFormatter",
"sets",
"up",
"the",
"text",
"formatting",
"for",
"logs",
"output",
"by",
"logrus",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L151-L164 |
163,748 | cilium/cilium | pkg/logging/logging.go | validateOpts | func validateOpts(logDriver string, logOpts map[string]string, supportedOpts map[string]bool) error {
for k := range logOpts {
if !supportedOpts[k] {
return fmt.Errorf("provided configuration value %q is not supported as a logging option for log driver %s", k, logDriver)
}
}
return nil
} | go | func validateOpts(logDriver string, logOpts map[string]string, supportedOpts map[string]bool) error {
for k := range logOpts {
if !supportedOpts[k] {
return fmt.Errorf("provided configuration value %q is not supported as a logging option for log driver %s", k, logDriver)
}
}
return nil
} | [
"func",
"validateOpts",
"(",
"logDriver",
"string",
",",
"logOpts",
"map",
"[",
"string",
"]",
"string",
",",
"supportedOpts",
"map",
"[",
"string",
"]",
"bool",
")",
"error",
"{",
"for",
"k",
":=",
"range",
"logOpts",
"{",
"if",
"!",
"supportedOpts",
"[... | // validateOpts iterates through all of the keys in logOpts, and errors out if
// the key in logOpts is not a key in supportedOpts. | [
"validateOpts",
"iterates",
"through",
"all",
"of",
"the",
"keys",
"in",
"logOpts",
"and",
"errors",
"out",
"if",
"the",
"key",
"in",
"logOpts",
"is",
"not",
"a",
"key",
"in",
"supportedOpts",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L168-L175 |
163,749 | cilium/cilium | pkg/logging/logging.go | getLogDriverConfig | func getLogDriverConfig(logDriver string, logOpts map[string]string) map[string]string {
keysToValidate := make(map[string]string)
for k, v := range logOpts {
ok, err := regexp.MatchString(logDriver+".*", k)
if err != nil {
DefaultLogger.Fatal(err)
}
if ok {
keysToValidate[k] = v
}
}
return keysToValidate
} | go | func getLogDriverConfig(logDriver string, logOpts map[string]string) map[string]string {
keysToValidate := make(map[string]string)
for k, v := range logOpts {
ok, err := regexp.MatchString(logDriver+".*", k)
if err != nil {
DefaultLogger.Fatal(err)
}
if ok {
keysToValidate[k] = v
}
}
return keysToValidate
} | [
"func",
"getLogDriverConfig",
"(",
"logDriver",
"string",
",",
"logOpts",
"map",
"[",
"string",
"]",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"keysToValidate",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"k",... | // getLogDriverConfig returns a map containing the key-value pairs that start
// with string logDriver from map logOpts. | [
"getLogDriverConfig",
"returns",
"a",
"map",
"containing",
"the",
"key",
"-",
"value",
"pairs",
"that",
"start",
"with",
"string",
"logDriver",
"from",
"map",
"logOpts",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L179-L191 |
163,750 | cilium/cilium | pkg/logging/logging.go | MultiLine | func MultiLine(logFn func(args ...interface{}), output string) {
scanner := bufio.NewScanner(bytes.NewReader([]byte(output)))
for scanner.Scan() {
logFn(scanner.Text())
}
} | go | func MultiLine(logFn func(args ...interface{}), output string) {
scanner := bufio.NewScanner(bytes.NewReader([]byte(output)))
for scanner.Scan() {
logFn(scanner.Text())
}
} | [
"func",
"MultiLine",
"(",
"logFn",
"func",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
",",
"output",
"string",
")",
"{",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"bytes",
".",
"NewReader",
"(",
"[",
"]",
"byte",
"(",
"output",
")",
")",... | // MultiLine breaks a multi line text into individual log entries and calls the
// logging function to log each entry | [
"MultiLine",
"breaks",
"a",
"multi",
"line",
"text",
"into",
"individual",
"log",
"entries",
"and",
"calls",
"the",
"logging",
"function",
"to",
"log",
"each",
"entry"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L195-L200 |
163,751 | cilium/cilium | pkg/logging/logging.go | CanLogAt | func CanLogAt(logger *logrus.Logger, level logrus.Level) bool {
return GetLevel(logger) >= level
} | go | func CanLogAt(logger *logrus.Logger, level logrus.Level) bool {
return GetLevel(logger) >= level
} | [
"func",
"CanLogAt",
"(",
"logger",
"*",
"logrus",
".",
"Logger",
",",
"level",
"logrus",
".",
"Level",
")",
"bool",
"{",
"return",
"GetLevel",
"(",
"logger",
")",
">=",
"level",
"\n",
"}"
] | // CanLogAt returns whether a log message at the given level would be
// logged by the given logger. | [
"CanLogAt",
"returns",
"whether",
"a",
"log",
"message",
"at",
"the",
"given",
"level",
"would",
"be",
"logged",
"by",
"the",
"given",
"logger",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L204-L206 |
163,752 | cilium/cilium | pkg/logging/logging.go | GetLevel | func GetLevel(logger *logrus.Logger) logrus.Level {
return logrus.Level(atomic.LoadUint32((*uint32)(&logger.Level)))
} | go | func GetLevel(logger *logrus.Logger) logrus.Level {
return logrus.Level(atomic.LoadUint32((*uint32)(&logger.Level)))
} | [
"func",
"GetLevel",
"(",
"logger",
"*",
"logrus",
".",
"Logger",
")",
"logrus",
".",
"Level",
"{",
"return",
"logrus",
".",
"Level",
"(",
"atomic",
".",
"LoadUint32",
"(",
"(",
"*",
"uint32",
")",
"(",
"&",
"logger",
".",
"Level",
")",
")",
")",
"\... | // GetLevel returns the log level of the given logger. | [
"GetLevel",
"returns",
"the",
"log",
"level",
"of",
"the",
"given",
"logger",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/logging/logging.go#L209-L211 |
163,753 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_responses.go | WithPayload | func (o *GetFqdnCacheOK) WithPayload(payload []*models.DNSLookup) *GetFqdnCacheOK {
o.Payload = payload
return o
} | go | func (o *GetFqdnCacheOK) WithPayload(payload []*models.DNSLookup) *GetFqdnCacheOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"DNSLookup",
")",
"*",
"GetFqdnCacheOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get fqdn cache o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"fqdn",
"cache",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_responses.go#L38-L41 |
163,754 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_responses.go | WithPayload | func (o *GetFqdnCacheBadRequest) WithPayload(payload models.Error) *GetFqdnCacheBadRequest {
o.Payload = payload
return o
} | go | func (o *GetFqdnCacheBadRequest) WithPayload(payload models.Error) *GetFqdnCacheBadRequest {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheBadRequest",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"GetFqdnCacheBadRequest",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get fqdn cache bad request response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"fqdn",
"cache",
"bad",
"request",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_responses.go#L85-L88 |
163,755 | cilium/cilium | api/v1/health/models/status_response.go | Validate | func (m *StatusResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCilium(formats); err != nil {
res = append(res, err)
}
if err := m.validateCluster(formats); err != nil {
res = append(res, err)
}
if err := m.validateContainerRuntime(formats); err != nil {
res = append(res, err)
}
if err := m.validateControllers(formats); err != nil {
res = append(res, err)
}
if err := m.validateIPAM(formats); err != nil {
res = append(res, err)
}
if err := m.validateKubernetes(formats); err != nil {
res = append(res, err)
}
if err := m.validateKvstore(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodeMonitor(formats); err != nil {
res = append(res, err)
}
if err := m.validateProxy(formats); err != nil {
res = append(res, err)
}
if err := m.validateStale(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *StatusResponse) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCilium(formats); err != nil {
res = append(res, err)
}
if err := m.validateCluster(formats); err != nil {
res = append(res, err)
}
if err := m.validateContainerRuntime(formats); err != nil {
res = append(res, err)
}
if err := m.validateControllers(formats); err != nil {
res = append(res, err)
}
if err := m.validateIPAM(formats); err != nil {
res = append(res, err)
}
if err := m.validateKubernetes(formats); err != nil {
res = append(res, err)
}
if err := m.validateKvstore(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodeMonitor(formats); err != nil {
res = append(res, err)
}
if err := m.validateProxy(formats); err != nil {
res = append(res, err)
}
if err := m.validateStale(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"StatusResponse",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateCilium",
"(",
"formats",
")",
";",
"err",
"!=",
"ni... | // Validate validates this status response | [
"Validate",
"validates",
"this",
"status",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/status_response.go#L55-L102 |
163,756 | cilium/cilium | api/v1/health/models/status_response.go | Validate | func (m *StatusResponseClusterNodesItems0PrimaryAddress) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateIPV4(formats); err != nil {
res = append(res, err)
}
if err := m.validateIPV6(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *StatusResponseClusterNodesItems0PrimaryAddress) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateIPV4(formats); err != nil {
res = append(res, err)
}
if err := m.validateIPV6(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"StatusResponseClusterNodesItems0PrimaryAddress",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateIPV4",
"(",
"formats",
")",... | // Validate validates this status response cluster nodes items0 primary address | [
"Validate",
"validates",
"this",
"status",
"response",
"cluster",
"nodes",
"items0",
"primary",
"address"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/status_response.go#L882-L897 |
163,757 | cilium/cilium | api/v1/health/models/status_response.go | Validate | func (m *StatusResponseControllersItems0Configuration) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateErrorRetryBase(formats); err != nil {
res = append(res, err)
}
if err := m.validateInterval(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *StatusResponseControllersItems0Configuration) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateErrorRetryBase(formats); err != nil {
res = append(res, err)
}
if err := m.validateInterval(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"StatusResponseControllersItems0Configuration",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateErrorRetryBase",
"(",
"formats"... | // Validate validates this status response controllers items0 configuration | [
"Validate",
"validates",
"this",
"status",
"response",
"controllers",
"items0",
"configuration"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/status_response.go#L1290-L1305 |
163,758 | cilium/cilium | api/v1/health/models/status_response.go | Validate | func (m *StatusResponseControllersItems0Status) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLastFailureTimestamp(formats); err != nil {
res = append(res, err)
}
if err := m.validateLastSuccessTimestamp(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *StatusResponseControllersItems0Status) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateLastFailureTimestamp(formats); err != nil {
res = append(res, err)
}
if err := m.validateLastSuccessTimestamp(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"StatusResponseControllersItems0Status",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateLastFailureTimestamp",
"(",
"formats",... | // Validate validates this status response controllers items0 status | [
"Validate",
"validates",
"this",
"status",
"response",
"controllers",
"items0",
"status"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/status_response.go#L1377-L1392 |
163,759 | cilium/cilium | api/v1/health/models/status_response.go | Validate | func (m *StatusResponseKubernetes) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateState(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *StatusResponseKubernetes) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateState(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"StatusResponseKubernetes",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateState",
"(",
"formats",
")",
";",
"err",
"!... | // Validate validates this status response kubernetes | [
"Validate",
"validates",
"this",
"status",
"response",
"kubernetes"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/health/models/status_response.go#L1492-L1503 |
163,760 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_parameters.go | WithTimeout | func (o *GetEndpointIDParams) WithTimeout(timeout time.Duration) *GetEndpointIDParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetEndpointIDParams) WithTimeout(timeout time.Duration) *GetEndpointIDParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetEndpointIDParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get endpoint ID params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"endpoint",
"ID",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_parameters.go#L88-L91 |
163,761 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_parameters.go | WithContext | func (o *GetEndpointIDParams) WithContext(ctx context.Context) *GetEndpointIDParams {
o.SetContext(ctx)
return o
} | go | func (o *GetEndpointIDParams) WithContext(ctx context.Context) *GetEndpointIDParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetEndpointIDParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get endpoint ID params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"endpoint",
"ID",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_parameters.go#L99-L102 |
163,762 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_parameters.go | WithHTTPClient | func (o *GetEndpointIDParams) WithHTTPClient(client *http.Client) *GetEndpointIDParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetEndpointIDParams) WithHTTPClient(client *http.Client) *GetEndpointIDParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetEndpointIDParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get endpoint ID params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"endpoint",
"ID",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_parameters.go#L110-L113 |
163,763 | cilium/cilium | api/v1/client/endpoint/get_endpoint_id_parameters.go | WithID | func (o *GetEndpointIDParams) WithID(id string) *GetEndpointIDParams {
o.SetID(id)
return o
} | go | func (o *GetEndpointIDParams) WithID(id string) *GetEndpointIDParams {
o.SetID(id)
return o
} | [
"func",
"(",
"o",
"*",
"GetEndpointIDParams",
")",
"WithID",
"(",
"id",
"string",
")",
"*",
"GetEndpointIDParams",
"{",
"o",
".",
"SetID",
"(",
"id",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithID adds the id to the get endpoint ID params | [
"WithID",
"adds",
"the",
"id",
"to",
"the",
"get",
"endpoint",
"ID",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/endpoint/get_endpoint_id_parameters.go#L121-L124 |
163,764 | cilium/cilium | api/v1/client/service/get_service_parameters.go | WithTimeout | func (o *GetServiceParams) WithTimeout(timeout time.Duration) *GetServiceParams {
o.SetTimeout(timeout)
return o
} | go | func (o *GetServiceParams) WithTimeout(timeout time.Duration) *GetServiceParams {
o.SetTimeout(timeout)
return o
} | [
"func",
"(",
"o",
"*",
"GetServiceParams",
")",
"WithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"GetServiceParams",
"{",
"o",
".",
"SetTimeout",
"(",
"timeout",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithTimeout adds the timeout to the get service params | [
"WithTimeout",
"adds",
"the",
"timeout",
"to",
"the",
"get",
"service",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/get_service_parameters.go#L69-L72 |
163,765 | cilium/cilium | api/v1/client/service/get_service_parameters.go | WithContext | func (o *GetServiceParams) WithContext(ctx context.Context) *GetServiceParams {
o.SetContext(ctx)
return o
} | go | func (o *GetServiceParams) WithContext(ctx context.Context) *GetServiceParams {
o.SetContext(ctx)
return o
} | [
"func",
"(",
"o",
"*",
"GetServiceParams",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"GetServiceParams",
"{",
"o",
".",
"SetContext",
"(",
"ctx",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithContext adds the context to the get service params | [
"WithContext",
"adds",
"the",
"context",
"to",
"the",
"get",
"service",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/get_service_parameters.go#L80-L83 |
163,766 | cilium/cilium | api/v1/client/service/get_service_parameters.go | WithHTTPClient | func (o *GetServiceParams) WithHTTPClient(client *http.Client) *GetServiceParams {
o.SetHTTPClient(client)
return o
} | go | func (o *GetServiceParams) WithHTTPClient(client *http.Client) *GetServiceParams {
o.SetHTTPClient(client)
return o
} | [
"func",
"(",
"o",
"*",
"GetServiceParams",
")",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"*",
"GetServiceParams",
"{",
"o",
".",
"SetHTTPClient",
"(",
"client",
")",
"\n",
"return",
"o",
"\n",
"}"
] | // WithHTTPClient adds the HTTPClient to the get service params | [
"WithHTTPClient",
"adds",
"the",
"HTTPClient",
"to",
"the",
"get",
"service",
"params"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/client/service/get_service_parameters.go#L91-L94 |
163,767 | cilium/cilium | api/v1/server/restapi/policy/put_policy_responses.go | WithPayload | func (o *PutPolicyOK) WithPayload(payload *models.Policy) *PutPolicyOK {
o.Payload = payload
return o
} | go | func (o *PutPolicyOK) WithPayload(payload *models.Policy) *PutPolicyOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PutPolicyOK",
")",
"WithPayload",
"(",
"payload",
"*",
"models",
".",
"Policy",
")",
"*",
"PutPolicyOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the put policy o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"put",
"policy",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/put_policy_responses.go#L38-L41 |
163,768 | cilium/cilium | api/v1/server/restapi/policy/put_policy_responses.go | WithPayload | func (o *PutPolicyInvalidPolicy) WithPayload(payload models.Error) *PutPolicyInvalidPolicy {
o.Payload = payload
return o
} | go | func (o *PutPolicyInvalidPolicy) WithPayload(payload models.Error) *PutPolicyInvalidPolicy {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PutPolicyInvalidPolicy",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"PutPolicyInvalidPolicy",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the put policy invalid policy response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"put",
"policy",
"invalid",
"policy",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/put_policy_responses.go#L82-L85 |
163,769 | cilium/cilium | api/v1/server/restapi/policy/put_policy_responses.go | WithPayload | func (o *PutPolicyInvalidPath) WithPayload(payload models.Error) *PutPolicyInvalidPath {
o.Payload = payload
return o
} | go | func (o *PutPolicyInvalidPath) WithPayload(payload models.Error) *PutPolicyInvalidPath {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PutPolicyInvalidPath",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"PutPolicyInvalidPath",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the put policy invalid path response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"put",
"policy",
"invalid",
"path",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/put_policy_responses.go#L124-L127 |
163,770 | cilium/cilium | api/v1/server/restapi/policy/put_policy_responses.go | WithPayload | func (o *PutPolicyFailure) WithPayload(payload models.Error) *PutPolicyFailure {
o.Payload = payload
return o
} | go | func (o *PutPolicyFailure) WithPayload(payload models.Error) *PutPolicyFailure {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"PutPolicyFailure",
")",
"WithPayload",
"(",
"payload",
"models",
".",
"Error",
")",
"*",
"PutPolicyFailure",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the put policy failure response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"put",
"policy",
"failure",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/put_policy_responses.go#L166-L169 |
163,771 | cilium/cilium | api/v1/server/restapi/policy/get_fqdn_cache_parameters.go | bindMatchpattern | func (o *GetFqdnCacheParams) bindMatchpattern(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.Matchpattern = &raw
return nil
} | go | func (o *GetFqdnCacheParams) bindMatchpattern(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.Matchpattern = &raw
return nil
} | [
"func",
"(",
"o",
"*",
"GetFqdnCacheParams",
")",
"bindMatchpattern",
"(",
"rawData",
"[",
"]",
"string",
",",
"hasKey",
"bool",
",",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"raw",
"string",
"\n",
"if",
"len",
"(",
"rawData",
")",... | // bindMatchpattern binds and validates parameter Matchpattern from query. | [
"bindMatchpattern",
"binds",
"and",
"validates",
"parameter",
"Matchpattern",
"from",
"query",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/policy/get_fqdn_cache_parameters.go#L90-L105 |
163,772 | cilium/cilium | pkg/maps/eppolicymap/eppolicymap.go | newEndpointKey | func newEndpointKey(ip net.IP) *EndpointKey {
return &EndpointKey{
EndpointKey: bpf.NewEndpointKey(ip),
}
} | go | func newEndpointKey(ip net.IP) *EndpointKey {
return &EndpointKey{
EndpointKey: bpf.NewEndpointKey(ip),
}
} | [
"func",
"newEndpointKey",
"(",
"ip",
"net",
".",
"IP",
")",
"*",
"EndpointKey",
"{",
"return",
"&",
"EndpointKey",
"{",
"EndpointKey",
":",
"bpf",
".",
"NewEndpointKey",
"(",
"ip",
")",
",",
"}",
"\n",
"}"
] | // newEndpointKey return a new key from the IP address. | [
"newEndpointKey",
"return",
"a",
"new",
"key",
"from",
"the",
"IP",
"address",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/eppolicymap/eppolicymap.go#L101-L105 |
163,773 | cilium/cilium | pkg/maps/eppolicymap/eppolicymap.go | WriteEndpoint | func WriteEndpoint(keys []*lxcmap.EndpointKey, pm *policymap.PolicyMap) error {
return writeEndpoint(keys, pm.GetFd())
} | go | func WriteEndpoint(keys []*lxcmap.EndpointKey, pm *policymap.PolicyMap) error {
return writeEndpoint(keys, pm.GetFd())
} | [
"func",
"WriteEndpoint",
"(",
"keys",
"[",
"]",
"*",
"lxcmap",
".",
"EndpointKey",
",",
"pm",
"*",
"policymap",
".",
"PolicyMap",
")",
"error",
"{",
"return",
"writeEndpoint",
"(",
"keys",
",",
"pm",
".",
"GetFd",
"(",
")",
")",
"\n",
"}"
] | // WriteEndpoint writes the policy map file descriptor into the map so that
// the datapath side can do a lookup from EndpointKey->PolicyMap. Locking is
// handled in the usual way via Map lock. If sockops is disabled this will be
// a nop. | [
"WriteEndpoint",
"writes",
"the",
"policy",
"map",
"file",
"descriptor",
"into",
"the",
"map",
"so",
"that",
"the",
"datapath",
"side",
"can",
"do",
"a",
"lookup",
"from",
"EndpointKey",
"-",
">",
"PolicyMap",
".",
"Locking",
"is",
"handled",
"in",
"the",
... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/maps/eppolicymap/eppolicymap.go#L131-L133 |
163,774 | cilium/cilium | api/v1/models/daemon_configuration_status.go | Validate | func (m *DaemonConfigurationStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAddressing(formats); err != nil {
res = append(res, err)
}
if err := m.validateDatapathMode(formats); err != nil {
res = append(res, err)
}
if err := m.validateImmutable(formats); err != nil {
res = append(res, err)
}
if err := m.validateIpvlanConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateKvstoreConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodeMonitor(formats); err != nil {
res = append(res, err)
}
if err := m.validateRealized(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *DaemonConfigurationStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAddressing(formats); err != nil {
res = append(res, err)
}
if err := m.validateDatapathMode(formats); err != nil {
res = append(res, err)
}
if err := m.validateImmutable(formats); err != nil {
res = append(res, err)
}
if err := m.validateIpvlanConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateKvstoreConfiguration(formats); err != nil {
res = append(res, err)
}
if err := m.validateNodeMonitor(formats); err != nil {
res = append(res, err)
}
if err := m.validateRealized(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"DaemonConfigurationStatus",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateAddressing",
"(",
"formats",
")",
";",
"err"... | // Validate validates this daemon configuration status | [
"Validate",
"validates",
"this",
"daemon",
"configuration",
"status"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/daemon_configuration_status.go#L57-L92 |
163,775 | cilium/cilium | api/v1/models/endpoint_networking.go | Validate | func (m *EndpointNetworking) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAddressing(formats); err != nil {
res = append(res, err)
}
if err := m.validateHostAddressing(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *EndpointNetworking) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAddressing(formats); err != nil {
res = append(res, err)
}
if err := m.validateHostAddressing(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"EndpointNetworking",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateAddressing",
"(",
"formats",
")",
";",
"err",
"!=... | // Validate validates this endpoint networking | [
"Validate",
"validates",
"this",
"endpoint",
"networking"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/models/endpoint_networking.go#L41-L56 |
163,776 | cilium/cilium | api/v1/server/restapi/metrics/get_metrics_responses.go | WithPayload | func (o *GetMetricsOK) WithPayload(payload []*models.Metric) *GetMetricsOK {
o.Payload = payload
return o
} | go | func (o *GetMetricsOK) WithPayload(payload []*models.Metric) *GetMetricsOK {
o.Payload = payload
return o
} | [
"func",
"(",
"o",
"*",
"GetMetricsOK",
")",
"WithPayload",
"(",
"payload",
"[",
"]",
"*",
"models",
".",
"Metric",
")",
"*",
"GetMetricsOK",
"{",
"o",
".",
"Payload",
"=",
"payload",
"\n",
"return",
"o",
"\n",
"}"
] | // WithPayload adds the payload to the get metrics o k response | [
"WithPayload",
"adds",
"the",
"payload",
"to",
"the",
"get",
"metrics",
"o",
"k",
"response"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/metrics/get_metrics_responses.go#L38-L41 |
163,777 | cilium/cilium | pkg/labels/array.go | Sort | func (ls LabelArray) Sort() LabelArray {
sort.Slice(ls, func(i, j int) bool {
return ls[i].Key < ls[j].Key
})
return ls
} | go | func (ls LabelArray) Sort() LabelArray {
sort.Slice(ls, func(i, j int) bool {
return ls[i].Key < ls[j].Key
})
return ls
} | [
"func",
"(",
"ls",
"LabelArray",
")",
"Sort",
"(",
")",
"LabelArray",
"{",
"sort",
".",
"Slice",
"(",
"ls",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"ls",
"[",
"i",
"]",
".",
"Key",
"<",
"ls",
"[",
"j",
"]",
".",
... | // Sort is an internal utility to return all LabelArrays in sorted
// order, when the source material may be unsorted. 'ls' is sorted
// in-place, but also returns the sorted array for convenience. | [
"Sort",
"is",
"an",
"internal",
"utility",
"to",
"return",
"all",
"LabelArrays",
"in",
"sorted",
"order",
"when",
"the",
"source",
"material",
"may",
"be",
"unsorted",
".",
"ls",
"is",
"sorted",
"in",
"-",
"place",
"but",
"also",
"returns",
"the",
"sorted"... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L28-L33 |
163,778 | cilium/cilium | pkg/labels/array.go | ParseLabelArray | func ParseLabelArray(labels ...string) LabelArray {
array := make(LabelArray, len(labels))
for i := range labels {
array[i] = ParseLabel(labels[i])
}
return array.Sort()
} | go | func ParseLabelArray(labels ...string) LabelArray {
array := make(LabelArray, len(labels))
for i := range labels {
array[i] = ParseLabel(labels[i])
}
return array.Sort()
} | [
"func",
"ParseLabelArray",
"(",
"labels",
"...",
"string",
")",
"LabelArray",
"{",
"array",
":=",
"make",
"(",
"LabelArray",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"labels",
"{",
"array",
"[",
"i",
"]",
"=",
"ParseLabel",... | // ParseLabelArray parses a list of labels and returns a LabelArray | [
"ParseLabelArray",
"parses",
"a",
"list",
"of",
"labels",
"and",
"returns",
"a",
"LabelArray"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L36-L42 |
163,779 | cilium/cilium | pkg/labels/array.go | ParseSelectLabelArray | func ParseSelectLabelArray(labels ...string) LabelArray {
array := make(LabelArray, len(labels))
for i := range labels {
array[i] = ParseSelectLabel(labels[i])
}
return array.Sort()
} | go | func ParseSelectLabelArray(labels ...string) LabelArray {
array := make(LabelArray, len(labels))
for i := range labels {
array[i] = ParseSelectLabel(labels[i])
}
return array.Sort()
} | [
"func",
"ParseSelectLabelArray",
"(",
"labels",
"...",
"string",
")",
"LabelArray",
"{",
"array",
":=",
"make",
"(",
"LabelArray",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"labels",
"{",
"array",
"[",
"i",
"]",
"=",
"ParseS... | // ParseSelectLabelArray parses a list of select labels and returns a LabelArray | [
"ParseSelectLabelArray",
"parses",
"a",
"list",
"of",
"select",
"labels",
"and",
"returns",
"a",
"LabelArray"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L45-L51 |
163,780 | cilium/cilium | pkg/labels/array.go | ParseLabelArrayFromArray | func ParseLabelArrayFromArray(base []string) LabelArray {
array := make(LabelArray, len(base))
for i := range base {
array[i] = ParseLabel(base[i])
}
return array.Sort()
} | go | func ParseLabelArrayFromArray(base []string) LabelArray {
array := make(LabelArray, len(base))
for i := range base {
array[i] = ParseLabel(base[i])
}
return array.Sort()
} | [
"func",
"ParseLabelArrayFromArray",
"(",
"base",
"[",
"]",
"string",
")",
"LabelArray",
"{",
"array",
":=",
"make",
"(",
"LabelArray",
",",
"len",
"(",
"base",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"base",
"{",
"array",
"[",
"i",
"]",
"=",
"Pars... | // ParseLabelArrayFromArray converts an array of strings as labels and returns a LabelArray | [
"ParseLabelArrayFromArray",
"converts",
"an",
"array",
"of",
"strings",
"as",
"labels",
"and",
"returns",
"a",
"LabelArray"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L54-L60 |
163,781 | cilium/cilium | pkg/labels/array.go | ParseSelectLabelArrayFromArray | func ParseSelectLabelArrayFromArray(base []string) LabelArray {
array := make(LabelArray, len(base))
for i := range base {
array[i] = ParseSelectLabel(base[i])
}
return array.Sort()
} | go | func ParseSelectLabelArrayFromArray(base []string) LabelArray {
array := make(LabelArray, len(base))
for i := range base {
array[i] = ParseSelectLabel(base[i])
}
return array.Sort()
} | [
"func",
"ParseSelectLabelArrayFromArray",
"(",
"base",
"[",
"]",
"string",
")",
"LabelArray",
"{",
"array",
":=",
"make",
"(",
"LabelArray",
",",
"len",
"(",
"base",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"base",
"{",
"array",
"[",
"i",
"]",
"=",
... | // ParseSelectLabelArrayFromArray converts an array of strings as select labels and returns a LabelArray | [
"ParseSelectLabelArrayFromArray",
"converts",
"an",
"array",
"of",
"strings",
"as",
"select",
"labels",
"and",
"returns",
"a",
"LabelArray"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L76-L82 |
163,782 | cilium/cilium | pkg/labels/array.go | Labels | func (ls LabelArray) Labels() Labels {
lbls := Labels{}
for _, l := range ls {
lbls[l.Key] = l
}
return lbls
} | go | func (ls LabelArray) Labels() Labels {
lbls := Labels{}
for _, l := range ls {
lbls[l.Key] = l
}
return lbls
} | [
"func",
"(",
"ls",
"LabelArray",
")",
"Labels",
"(",
")",
"Labels",
"{",
"lbls",
":=",
"Labels",
"{",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"ls",
"{",
"lbls",
"[",
"l",
".",
"Key",
"]",
"=",
"l",
"\n",
"}",
"\n",
"return",
"lbls",
"... | // Labels returns the LabelArray as Labels | [
"Labels",
"returns",
"the",
"LabelArray",
"as",
"Labels"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L85-L91 |
163,783 | cilium/cilium | pkg/labels/array.go | Lacks | func (ls LabelArray) Lacks(needed LabelArray) LabelArray {
missing := LabelArray{}
nextLabel:
for i := range needed {
for l := range ls {
if needed[i].Matches(&ls[l]) {
continue nextLabel
}
}
missing = append(missing, needed[i])
}
return missing
} | go | func (ls LabelArray) Lacks(needed LabelArray) LabelArray {
missing := LabelArray{}
nextLabel:
for i := range needed {
for l := range ls {
if needed[i].Matches(&ls[l]) {
continue nextLabel
}
}
missing = append(missing, needed[i])
}
return missing
} | [
"func",
"(",
"ls",
"LabelArray",
")",
"Lacks",
"(",
"needed",
"LabelArray",
")",
"LabelArray",
"{",
"missing",
":=",
"LabelArray",
"{",
"}",
"\n",
"nextLabel",
":",
"for",
"i",
":=",
"range",
"needed",
"{",
"for",
"l",
":=",
"range",
"ls",
"{",
"if",
... | // Lacks is identical to Contains but returns all missing labels | [
"Lacks",
"is",
"identical",
"to",
"Contains",
"but",
"returns",
"all",
"missing",
"labels"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L111-L125 |
163,784 | cilium/cilium | pkg/labels/array.go | DeepCopy | func (ls LabelArray) DeepCopy() LabelArray {
if ls == nil {
return nil
}
o := make(LabelArray, len(ls), len(ls))
copy(o, ls)
return o
} | go | func (ls LabelArray) DeepCopy() LabelArray {
if ls == nil {
return nil
}
o := make(LabelArray, len(ls), len(ls))
copy(o, ls)
return o
} | [
"func",
"(",
"ls",
"LabelArray",
")",
"DeepCopy",
"(",
")",
"LabelArray",
"{",
"if",
"ls",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"o",
":=",
"make",
"(",
"LabelArray",
",",
"len",
"(",
"ls",
")",
",",
"len",
"(",
"ls",
")",
")",
... | // DeepCopy returns a deep copy of the labels. | [
"DeepCopy",
"returns",
"a",
"deep",
"copy",
"of",
"the",
"labels",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L170-L178 |
163,785 | cilium/cilium | pkg/labels/array.go | GetModel | func (ls LabelArray) GetModel() []string {
res := []string{}
for l := range ls {
res = append(res, ls[l].String())
}
return res
} | go | func (ls LabelArray) GetModel() []string {
res := []string{}
for l := range ls {
res = append(res, ls[l].String())
}
return res
} | [
"func",
"(",
"ls",
"LabelArray",
")",
"GetModel",
"(",
")",
"[",
"]",
"string",
"{",
"res",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"l",
":=",
"range",
"ls",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ls",
"[",
"l",
"]",
".",
"Stri... | // GetModel returns the LabelArray as a string array with fully-qualified labels.
// The output is parseable by ParseLabelArrayFromArray | [
"GetModel",
"returns",
"the",
"LabelArray",
"as",
"a",
"string",
"array",
"with",
"fully",
"-",
"qualified",
"labels",
".",
"The",
"output",
"is",
"parseable",
"by",
"ParseLabelArrayFromArray"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/array.go#L182-L188 |
163,786 | cilium/cilium | pkg/monitor/format/format.go | NewMonitorFormatter | func NewMonitorFormatter(verbosity Verbosity) *MonitorFormatter {
return &MonitorFormatter{
Hex: false,
EventTypes: monitorAPI.MessageTypeFilter{},
FromSource: Uint16Flags{},
ToDst: Uint16Flags{},
Related: Uint16Flags{},
Verbose: false,
JSONOutput: false,
Verbosity: verbosity,
}
} | go | func NewMonitorFormatter(verbosity Verbosity) *MonitorFormatter {
return &MonitorFormatter{
Hex: false,
EventTypes: monitorAPI.MessageTypeFilter{},
FromSource: Uint16Flags{},
ToDst: Uint16Flags{},
Related: Uint16Flags{},
Verbose: false,
JSONOutput: false,
Verbosity: verbosity,
}
} | [
"func",
"NewMonitorFormatter",
"(",
"verbosity",
"Verbosity",
")",
"*",
"MonitorFormatter",
"{",
"return",
"&",
"MonitorFormatter",
"{",
"Hex",
":",
"false",
",",
"EventTypes",
":",
"monitorAPI",
".",
"MessageTypeFilter",
"{",
"}",
",",
"FromSource",
":",
"Uint1... | // NewMonitorFormatter returns a new formatter with default configuration. | [
"NewMonitorFormatter",
"returns",
"a",
"new",
"formatter",
"with",
"default",
"configuration",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L65-L76 |
163,787 | cilium/cilium | pkg/monitor/format/format.go | dropEvents | func (m *MonitorFormatter) dropEvents(prefix string, data []byte) {
dn := monitor.DropNotify{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dn); err != nil {
fmt.Printf("Error while parsing drop notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeDrop, dn.Source, uint16(dn.DstID)) {
switch m.Verbosity {
case INFO:
dn.DumpInfo(data)
case JSON:
dn.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
dn.DumpVerbose(!m.Hex, data, prefix)
}
}
} | go | func (m *MonitorFormatter) dropEvents(prefix string, data []byte) {
dn := monitor.DropNotify{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dn); err != nil {
fmt.Printf("Error while parsing drop notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeDrop, dn.Source, uint16(dn.DstID)) {
switch m.Verbosity {
case INFO:
dn.DumpInfo(data)
case JSON:
dn.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
dn.DumpVerbose(!m.Hex, data, prefix)
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"dropEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"dn",
":=",
"monitor",
".",
"DropNotify",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"bytes",
".",
... | // dropEvents prints out all the received drop notifications. | [
"dropEvents",
"prints",
"out",
"all",
"the",
"received",
"drop",
"notifications",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L97-L114 |
163,788 | cilium/cilium | pkg/monitor/format/format.go | traceEvents | func (m *MonitorFormatter) traceEvents(prefix string, data []byte) {
tn := monitor.TraceNotify{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &tn); err != nil {
fmt.Printf("Error while parsing trace notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeTrace, tn.Source, tn.DstID) {
switch m.Verbosity {
case INFO:
tn.DumpInfo(data)
case JSON:
tn.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
tn.DumpVerbose(!m.Hex, data, prefix)
}
}
} | go | func (m *MonitorFormatter) traceEvents(prefix string, data []byte) {
tn := monitor.TraceNotify{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &tn); err != nil {
fmt.Printf("Error while parsing trace notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeTrace, tn.Source, tn.DstID) {
switch m.Verbosity {
case INFO:
tn.DumpInfo(data)
case JSON:
tn.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
tn.DumpVerbose(!m.Hex, data, prefix)
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"traceEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"tn",
":=",
"monitor",
".",
"TraceNotify",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"bytes",
".",... | // traceEvents prints out all the received trace notifications. | [
"traceEvents",
"prints",
"out",
"all",
"the",
"received",
"trace",
"notifications",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L117-L134 |
163,789 | cilium/cilium | pkg/monitor/format/format.go | debugEvents | func (m *MonitorFormatter) debugEvents(prefix string, data []byte) {
dm := monitor.DebugMsg{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dm); err != nil {
fmt.Printf("Error while parsing debug message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeDebug, dm.Source, 0) {
switch m.Verbosity {
case INFO:
dm.DumpInfo(data)
case JSON:
dm.DumpJSON(prefix)
default:
dm.Dump(prefix)
}
}
} | go | func (m *MonitorFormatter) debugEvents(prefix string, data []byte) {
dm := monitor.DebugMsg{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dm); err != nil {
fmt.Printf("Error while parsing debug message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeDebug, dm.Source, 0) {
switch m.Verbosity {
case INFO:
dm.DumpInfo(data)
case JSON:
dm.DumpJSON(prefix)
default:
dm.Dump(prefix)
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"debugEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"dm",
":=",
"monitor",
".",
"DebugMsg",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"bytes",
".",
... | // debugEvents prints out all the debug messages. | [
"debugEvents",
"prints",
"out",
"all",
"the",
"debug",
"messages",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L137-L153 |
163,790 | cilium/cilium | pkg/monitor/format/format.go | captureEvents | func (m *MonitorFormatter) captureEvents(prefix string, data []byte) {
dc := monitor.DebugCapture{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dc); err != nil {
fmt.Printf("Error while parsing debug capture message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeCapture, dc.Source, 0) {
switch m.Verbosity {
case INFO:
dc.DumpInfo(data)
case JSON:
dc.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
dc.DumpVerbose(!m.Hex, data, prefix)
}
}
} | go | func (m *MonitorFormatter) captureEvents(prefix string, data []byte) {
dc := monitor.DebugCapture{}
if err := binary.Read(bytes.NewReader(data), byteorder.Native, &dc); err != nil {
fmt.Printf("Error while parsing debug capture message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeCapture, dc.Source, 0) {
switch m.Verbosity {
case INFO:
dc.DumpInfo(data)
case JSON:
dc.DumpJSON(data, prefix)
default:
fmt.Println(msgSeparator)
dc.DumpVerbose(!m.Hex, data, prefix)
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"captureEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"dc",
":=",
"monitor",
".",
"DebugCapture",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"binary",
".",
"Read",
"(",
"bytes",
"... | // captureEvents prints out all the capture messages. | [
"captureEvents",
"prints",
"out",
"all",
"the",
"capture",
"messages",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L156-L173 |
163,791 | cilium/cilium | pkg/monitor/format/format.go | logRecordEvents | func (m *MonitorFormatter) logRecordEvents(prefix string, data []byte) {
buf := bytes.NewBuffer(data[1:])
dec := gob.NewDecoder(buf)
lr := monitor.LogRecordNotify{}
if err := dec.Decode(&lr); err != nil {
fmt.Printf("Error while decoding LogRecord notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeAccessLog, uint16(lr.SourceEndpoint.ID), uint16(lr.DestinationEndpoint.ID)) {
if m.Verbosity == JSON {
lr.DumpJSON()
} else {
lr.DumpInfo()
}
}
} | go | func (m *MonitorFormatter) logRecordEvents(prefix string, data []byte) {
buf := bytes.NewBuffer(data[1:])
dec := gob.NewDecoder(buf)
lr := monitor.LogRecordNotify{}
if err := dec.Decode(&lr); err != nil {
fmt.Printf("Error while decoding LogRecord notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeAccessLog, uint16(lr.SourceEndpoint.ID), uint16(lr.DestinationEndpoint.ID)) {
if m.Verbosity == JSON {
lr.DumpJSON()
} else {
lr.DumpInfo()
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"logRecordEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"data",
"[",
"1",
":",
"]",
")",
"\n",
"dec",
":=",
"gob",
".",
"NewDe... | // logRecordEvents prints out LogRecord events | [
"logRecordEvents",
"prints",
"out",
"LogRecord",
"events"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L176-L192 |
163,792 | cilium/cilium | pkg/monitor/format/format.go | agentEvents | func (m *MonitorFormatter) agentEvents(prefix string, data []byte) {
buf := bytes.NewBuffer(data[1:])
dec := gob.NewDecoder(buf)
an := monitorAPI.AgentNotify{}
if err := dec.Decode(&an); err != nil {
fmt.Printf("Error while decoding agent notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeAgent, 0, 0) {
if m.Verbosity == JSON {
an.DumpJSON()
} else {
an.DumpInfo()
}
}
} | go | func (m *MonitorFormatter) agentEvents(prefix string, data []byte) {
buf := bytes.NewBuffer(data[1:])
dec := gob.NewDecoder(buf)
an := monitorAPI.AgentNotify{}
if err := dec.Decode(&an); err != nil {
fmt.Printf("Error while decoding agent notification message: %s\n", err)
}
if m.match(monitorAPI.MessageTypeAgent, 0, 0) {
if m.Verbosity == JSON {
an.DumpJSON()
} else {
an.DumpInfo()
}
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"agentEvents",
"(",
"prefix",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"data",
"[",
"1",
":",
"]",
")",
"\n",
"dec",
":=",
"gob",
".",
"NewDecode... | // agentEvents prints out agent events | [
"agentEvents",
"prints",
"out",
"agent",
"events"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L195-L211 |
163,793 | cilium/cilium | pkg/monitor/format/format.go | FormatSample | func (m *MonitorFormatter) FormatSample(data []byte, cpu int) {
prefix := fmt.Sprintf("CPU %02d:", cpu)
messageType := data[0]
switch messageType {
case monitorAPI.MessageTypeDrop:
m.dropEvents(prefix, data)
case monitorAPI.MessageTypeDebug:
m.debugEvents(prefix, data)
case monitorAPI.MessageTypeCapture:
m.captureEvents(prefix, data)
case monitorAPI.MessageTypeTrace:
m.traceEvents(prefix, data)
case monitorAPI.MessageTypeAccessLog:
m.logRecordEvents(prefix, data)
case monitorAPI.MessageTypeAgent:
m.agentEvents(prefix, data)
default:
fmt.Printf("%s Unknown event: %+v\n", prefix, data)
}
} | go | func (m *MonitorFormatter) FormatSample(data []byte, cpu int) {
prefix := fmt.Sprintf("CPU %02d:", cpu)
messageType := data[0]
switch messageType {
case monitorAPI.MessageTypeDrop:
m.dropEvents(prefix, data)
case monitorAPI.MessageTypeDebug:
m.debugEvents(prefix, data)
case monitorAPI.MessageTypeCapture:
m.captureEvents(prefix, data)
case monitorAPI.MessageTypeTrace:
m.traceEvents(prefix, data)
case monitorAPI.MessageTypeAccessLog:
m.logRecordEvents(prefix, data)
case monitorAPI.MessageTypeAgent:
m.agentEvents(prefix, data)
default:
fmt.Printf("%s Unknown event: %+v\n", prefix, data)
}
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"FormatSample",
"(",
"data",
"[",
"]",
"byte",
",",
"cpu",
"int",
")",
"{",
"prefix",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cpu",
")",
"\n",
"messageType",
":=",
"data",
"[",
"0",
"]",
... | // FormatSample prints an event from the provided raw data slice to stdout.
//
// For most monitor event types, 'data' corresponds to the 'data' field in
// bpf.PerfEventSample. Exceptions are MessageTypeAccessLog and
// MessageTypeAgent. | [
"FormatSample",
"prints",
"an",
"event",
"from",
"the",
"provided",
"raw",
"data",
"slice",
"to",
"stdout",
".",
"For",
"most",
"monitor",
"event",
"types",
"data",
"corresponds",
"to",
"the",
"data",
"field",
"in",
"bpf",
".",
"PerfEventSample",
".",
"Excep... | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L218-L238 |
163,794 | cilium/cilium | pkg/monitor/format/format.go | FormatEvent | func (m *MonitorFormatter) FormatEvent(pl *payload.Payload) bool {
switch pl.Type {
case payload.EventSample:
m.FormatSample(pl.Data, pl.CPU)
case payload.RecordLost:
LostEvent(pl.Lost, pl.CPU)
default:
return false
}
return true
} | go | func (m *MonitorFormatter) FormatEvent(pl *payload.Payload) bool {
switch pl.Type {
case payload.EventSample:
m.FormatSample(pl.Data, pl.CPU)
case payload.RecordLost:
LostEvent(pl.Lost, pl.CPU)
default:
return false
}
return true
} | [
"func",
"(",
"m",
"*",
"MonitorFormatter",
")",
"FormatEvent",
"(",
"pl",
"*",
"payload",
".",
"Payload",
")",
"bool",
"{",
"switch",
"pl",
".",
"Type",
"{",
"case",
"payload",
".",
"EventSample",
":",
"m",
".",
"FormatSample",
"(",
"pl",
".",
"Data",
... | // FormatEvent formats an event from the specified payload to stdout.
//
// Returns true if the event was successfully printed, false otherwise. | [
"FormatEvent",
"formats",
"an",
"event",
"from",
"the",
"specified",
"payload",
"to",
"stdout",
".",
"Returns",
"true",
"if",
"the",
"event",
"was",
"successfully",
"printed",
"false",
"otherwise",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/monitor/format/format.go#L248-L259 |
163,795 | cilium/cilium | pkg/policy/groups/helpers.go | createDerivativeCNP | func createDerivativeCNP(cnp *cilium_v2.CiliumNetworkPolicy) (*cilium_v2.CiliumNetworkPolicy, error) {
// CNP informer may provide a CNP object without APIVersion or Kind.
// Setting manually to make sure that the derivative policy works ok.
derivativeCNP := &cilium_v2.CiliumNetworkPolicy{
ObjectMeta: v1.ObjectMeta{
Name: getDerivativeName(cnp),
Namespace: cnp.ObjectMeta.Namespace,
OwnerReferences: []v1.OwnerReference{{
APIVersion: cilium_v2.SchemeGroupVersion.String(),
Kind: cilium_v2.CNPKindDefinition,
Name: cnp.ObjectMeta.Name,
UID: cnp.ObjectMeta.UID,
BlockOwnerDeletion: &blockOwnerDeletionPtr,
}},
Labels: map[string]string{
parentCNP: string(cnp.ObjectMeta.UID),
cnpKindKey: cnpKindName,
},
},
}
rules, err := cnp.Parse()
if err != nil {
return nil, fmt.Errorf("Cannot parse policies: %s", err)
}
derivativeCNP.Specs = make(api.Rules, len(rules))
for i, rule := range rules {
if rule.RequiresDerivative() {
derivativeCNP.Specs[i] = denyEgressRule()
}
}
for i, rule := range rules {
if !rule.RequiresDerivative() {
derivativeCNP.Specs[i] = rule
continue
}
newRule, err := rule.CreateDerivative()
if err != nil {
return derivativeCNP, err
}
derivativeCNP.Specs[i] = newRule
}
return derivativeCNP, nil
} | go | func createDerivativeCNP(cnp *cilium_v2.CiliumNetworkPolicy) (*cilium_v2.CiliumNetworkPolicy, error) {
// CNP informer may provide a CNP object without APIVersion or Kind.
// Setting manually to make sure that the derivative policy works ok.
derivativeCNP := &cilium_v2.CiliumNetworkPolicy{
ObjectMeta: v1.ObjectMeta{
Name: getDerivativeName(cnp),
Namespace: cnp.ObjectMeta.Namespace,
OwnerReferences: []v1.OwnerReference{{
APIVersion: cilium_v2.SchemeGroupVersion.String(),
Kind: cilium_v2.CNPKindDefinition,
Name: cnp.ObjectMeta.Name,
UID: cnp.ObjectMeta.UID,
BlockOwnerDeletion: &blockOwnerDeletionPtr,
}},
Labels: map[string]string{
parentCNP: string(cnp.ObjectMeta.UID),
cnpKindKey: cnpKindName,
},
},
}
rules, err := cnp.Parse()
if err != nil {
return nil, fmt.Errorf("Cannot parse policies: %s", err)
}
derivativeCNP.Specs = make(api.Rules, len(rules))
for i, rule := range rules {
if rule.RequiresDerivative() {
derivativeCNP.Specs[i] = denyEgressRule()
}
}
for i, rule := range rules {
if !rule.RequiresDerivative() {
derivativeCNP.Specs[i] = rule
continue
}
newRule, err := rule.CreateDerivative()
if err != nil {
return derivativeCNP, err
}
derivativeCNP.Specs[i] = newRule
}
return derivativeCNP, nil
} | [
"func",
"createDerivativeCNP",
"(",
"cnp",
"*",
"cilium_v2",
".",
"CiliumNetworkPolicy",
")",
"(",
"*",
"cilium_v2",
".",
"CiliumNetworkPolicy",
",",
"error",
")",
"{",
"// CNP informer may provide a CNP object without APIVersion or Kind.",
"// Setting manually to make sure tha... | // createDerivativeCNP will return a new CNP based on the given rule. | [
"createDerivativeCNP",
"will",
"return",
"a",
"new",
"CNP",
"based",
"on",
"the",
"given",
"rule",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/policy/groups/helpers.go#L45-L90 |
163,796 | cilium/cilium | api/v1/server/restapi/ipam/post_ip_a_m.go | NewPostIPAM | func NewPostIPAM(ctx *middleware.Context, handler PostIPAMHandler) *PostIPAM {
return &PostIPAM{Context: ctx, Handler: handler}
} | go | func NewPostIPAM(ctx *middleware.Context, handler PostIPAMHandler) *PostIPAM {
return &PostIPAM{Context: ctx, Handler: handler}
} | [
"func",
"NewPostIPAM",
"(",
"ctx",
"*",
"middleware",
".",
"Context",
",",
"handler",
"PostIPAMHandler",
")",
"*",
"PostIPAM",
"{",
"return",
"&",
"PostIPAM",
"{",
"Context",
":",
"ctx",
",",
"Handler",
":",
"handler",
"}",
"\n",
"}"
] | // NewPostIPAM creates a new http.Handler for the post IP a m operation | [
"NewPostIPAM",
"creates",
"a",
"new",
"http",
".",
"Handler",
"for",
"the",
"post",
"IP",
"a",
"m",
"operation"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/api/v1/server/restapi/ipam/post_ip_a_m.go#L28-L30 |
163,797 | cilium/cilium | pkg/labels/model/model.go | NewOplabelsFromModel | func NewOplabelsFromModel(base *models.LabelConfigurationStatus) *labels.OpLabels {
if base == nil {
return nil
}
return &labels.OpLabels{
Custom: labels.NewLabelsFromModel(base.Realized.User),
Disabled: labels.NewLabelsFromModel(base.Disabled),
OrchestrationIdentity: labels.NewLabelsFromModel(base.SecurityRelevant),
OrchestrationInfo: labels.NewLabelsFromModel(base.Derived),
}
} | go | func NewOplabelsFromModel(base *models.LabelConfigurationStatus) *labels.OpLabels {
if base == nil {
return nil
}
return &labels.OpLabels{
Custom: labels.NewLabelsFromModel(base.Realized.User),
Disabled: labels.NewLabelsFromModel(base.Disabled),
OrchestrationIdentity: labels.NewLabelsFromModel(base.SecurityRelevant),
OrchestrationInfo: labels.NewLabelsFromModel(base.Derived),
}
} | [
"func",
"NewOplabelsFromModel",
"(",
"base",
"*",
"models",
".",
"LabelConfigurationStatus",
")",
"*",
"labels",
".",
"OpLabels",
"{",
"if",
"base",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"&",
"labels",
".",
"OpLabels",
"{",
"Custo... | // NewOplabelsFromModel creates new label from the model. | [
"NewOplabelsFromModel",
"creates",
"new",
"label",
"from",
"the",
"model",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/labels/model/model.go#L23-L34 |
163,798 | cilium/cilium | pkg/identity/identity.go | GetLabelsSHA256 | func (id *Identity) GetLabelsSHA256() string {
if id.LabelsSHA256 == "" {
id.LabelsSHA256 = id.Labels.SHA256Sum()
}
return id.LabelsSHA256
} | go | func (id *Identity) GetLabelsSHA256() string {
if id.LabelsSHA256 == "" {
id.LabelsSHA256 = id.Labels.SHA256Sum()
}
return id.LabelsSHA256
} | [
"func",
"(",
"id",
"*",
"Identity",
")",
"GetLabelsSHA256",
"(",
")",
"string",
"{",
"if",
"id",
".",
"LabelsSHA256",
"==",
"\"",
"\"",
"{",
"id",
".",
"LabelsSHA256",
"=",
"id",
".",
"Labels",
".",
"SHA256Sum",
"(",
")",
"\n",
"}",
"\n\n",
"return",... | // GetLabelsSHA256 returns the SHA256 of the labels associated with the
// identity. The SHA is calculated if not already cached. | [
"GetLabelsSHA256",
"returns",
"the",
"SHA256",
"of",
"the",
"labels",
"associated",
"with",
"the",
"identity",
".",
"The",
"SHA",
"is",
"calculated",
"if",
"not",
"already",
"cached",
"."
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/identity/identity.go#L99-L105 |
163,799 | cilium/cilium | pkg/identity/identity.go | NewIdentityFromLabelArray | func NewIdentityFromLabelArray(id NumericIdentity, lblArray labels.LabelArray) *Identity {
var lbls labels.Labels
if lblArray != nil {
lbls = lblArray.Labels()
}
return &Identity{ID: id, Labels: lbls, LabelArray: lblArray}
} | go | func NewIdentityFromLabelArray(id NumericIdentity, lblArray labels.LabelArray) *Identity {
var lbls labels.Labels
if lblArray != nil {
lbls = lblArray.Labels()
}
return &Identity{ID: id, Labels: lbls, LabelArray: lblArray}
} | [
"func",
"NewIdentityFromLabelArray",
"(",
"id",
"NumericIdentity",
",",
"lblArray",
"labels",
".",
"LabelArray",
")",
"*",
"Identity",
"{",
"var",
"lbls",
"labels",
".",
"Labels",
"\n\n",
"if",
"lblArray",
"!=",
"nil",
"{",
"lbls",
"=",
"lblArray",
".",
"Lab... | // NewIdentityFromLabelArray creates a new identity | [
"NewIdentityFromLabelArray",
"creates",
"a",
"new",
"identity"
] | 6ecfff82c2314dd9d847645361b57e2646eed64b | https://github.com/cilium/cilium/blob/6ecfff82c2314dd9d847645361b57e2646eed64b/pkg/identity/identity.go#L149-L156 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.