id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,000 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | Unregister | func (r *Registry) Unregister(puID string) error {
r.Lock()
defer r.Unlock()
delete(r.indexByName, puID)
r.indexByPort.DeleteByID(puID, true)
r.indexByPort.DeleteByID(puID, false)
return nil
} | go | func (r *Registry) Unregister(puID string) error {
r.Lock()
defer r.Unlock()
delete(r.indexByName, puID)
r.indexByPort.DeleteByID(puID, true)
r.indexByPort.DeleteByID(puID, false)
return nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"Unregister",
"(",
"puID",
"string",
")",
"error",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"r",
".",
"indexByName",
",",
"puID",
")",
"\n",
"r",
".",
"indexByPort",
".",
"DeleteByID",
"(",
"puID",
",",
"true",
")",
"\n",
"r",
".",
"indexByPort",
".",
"DeleteByID",
"(",
"puID",
",",
"false",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Unregister unregisters a pu from the registry. | [
"Unregister",
"unregisters",
"a",
"pu",
"from",
"the",
"registry",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L114-L122 |
7,001 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | RetrieveServiceByID | func (r *Registry) RetrieveServiceByID(id string) (*ServiceContext, error) {
r.Lock()
defer r.Unlock()
svc, ok := r.indexByName[id]
if !ok {
return nil, fmt.Errorf("Service not found: %s", id)
}
return svc, nil
} | go | func (r *Registry) RetrieveServiceByID(id string) (*ServiceContext, error) {
r.Lock()
defer r.Unlock()
svc, ok := r.indexByName[id]
if !ok {
return nil, fmt.Errorf("Service not found: %s", id)
}
return svc, nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"RetrieveServiceByID",
"(",
"id",
"string",
")",
"(",
"*",
"ServiceContext",
",",
"error",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"svc",
",",
"ok",
":=",
"r",
".",
"indexByName",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n\n",
"return",
"svc",
",",
"nil",
"\n",
"}"
] | // RetrieveServiceByID retrieves a service by the PU ID. Returns error if not found. | [
"RetrieveServiceByID",
"retrieves",
"a",
"service",
"by",
"the",
"PU",
"ID",
".",
"Returns",
"error",
"if",
"not",
"found",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L125-L135 |
7,002 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | RetrieveExposedServiceContext | func (r *Registry) RetrieveExposedServiceContext(ip net.IP, port int, host string) (*PortContext, error) {
r.Lock()
defer r.Unlock()
data := r.indexByPort.Find(ip, port, host, true)
if data == nil {
return nil, fmt.Errorf("Service information not found: %s %d %s", ip.String(), port, host)
}
portContext, ok := data.(*PortContext)
if !ok {
return nil, fmt.Errorf("Internal server error")
}
return portContext, nil
} | go | func (r *Registry) RetrieveExposedServiceContext(ip net.IP, port int, host string) (*PortContext, error) {
r.Lock()
defer r.Unlock()
data := r.indexByPort.Find(ip, port, host, true)
if data == nil {
return nil, fmt.Errorf("Service information not found: %s %d %s", ip.String(), port, host)
}
portContext, ok := data.(*PortContext)
if !ok {
return nil, fmt.Errorf("Internal server error")
}
return portContext, nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"RetrieveExposedServiceContext",
"(",
"ip",
"net",
".",
"IP",
",",
"port",
"int",
",",
"host",
"string",
")",
"(",
"*",
"PortContext",
",",
"error",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"data",
":=",
"r",
".",
"indexByPort",
".",
"Find",
"(",
"ip",
",",
"port",
",",
"host",
",",
"true",
")",
"\n",
"if",
"data",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ip",
".",
"String",
"(",
")",
",",
"port",
",",
"host",
")",
"\n",
"}",
"\n\n",
"portContext",
",",
"ok",
":=",
"data",
".",
"(",
"*",
"PortContext",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"portContext",
",",
"nil",
"\n",
"}"
] | // RetrieveExposedServiceContext retrieves a service by the provided IP and or port. This
// is called by the network side of processing to find the context. | [
"RetrieveExposedServiceContext",
"retrieves",
"a",
"service",
"by",
"the",
"provided",
"IP",
"and",
"or",
"port",
".",
"This",
"is",
"called",
"by",
"the",
"network",
"side",
"of",
"processing",
"to",
"find",
"the",
"context",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L139-L154 |
7,003 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | updateExposedPortAssociations | func (r *Registry) updateExposedPortAssociations(sctx *ServiceContext, service *policy.ApplicationService, secrets secrets.Secrets) error {
// Do All the basic validations first.
if service.PrivateNetworkInfo == nil {
return fmt.Errorf("Private network is required for exposed services")
}
port, err := service.PrivateNetworkInfo.Ports.SinglePort()
if err != nil {
return fmt.Errorf("Multi-port is not supported for exposed services: %s", err)
}
if service.PublicNetworkInfo != nil {
if _, err := service.PublicNetworkInfo.Ports.SinglePort(); err != nil {
return fmt.Errorf("Multi-port is not supported for public network services: %s", err)
}
}
// Find any existing state and get the authorizer. We do not want
// to re-initialize the authorizer for every policy update.
authProcessor, err := r.createOrUpdateAuthProcessor(sctx, service, secrets)
if err != nil {
return err
}
clientCAs := x509.NewCertPool()
if (service.UserAuthorizationType == policy.UserAuthorizationMutualTLS || service.UserAuthorizationType == policy.UserAuthorizationJWT) &&
len(service.MutualTLSTrustedRoots) > 0 {
if !clientCAs.AppendCertsFromPEM(service.MutualTLSTrustedRoots) {
return fmt.Errorf("Unable to process client CAs")
}
}
// Add the new references.
if err := r.indexByPort.Add(
service.PrivateNetworkInfo,
sctx.PU.ContextID,
&PortContext{
ID: sctx.PU.ContextID,
Service: service,
TargetPort: int(port),
Type: serviceTypeToNetworkListenerType(service.Type, false),
Authorizer: authProcessor,
ClientTrustedRoots: clientCAs,
PUContext: sctx.PUContext,
},
true,
); err != nil {
return fmt.Errorf("Possible port overlap: %s", err)
}
if service.Type == policy.ServiceHTTP && service.PublicNetworkInfo != nil {
if err := r.indexByPort.Add(
service.PublicNetworkInfo,
sctx.PU.ContextID,
&PortContext{
ID: sctx.PU.ContextID,
Service: service,
TargetPort: int(port),
Type: serviceTypeToNetworkListenerType(service.Type, service.PublicServiceNoTLS),
Authorizer: authProcessor,
ClientTrustedRoots: clientCAs,
PUContext: sctx.PUContext,
},
true,
); err != nil {
return fmt.Errorf("Possible port overlap with public services: %s", err)
}
}
return nil
} | go | func (r *Registry) updateExposedPortAssociations(sctx *ServiceContext, service *policy.ApplicationService, secrets secrets.Secrets) error {
// Do All the basic validations first.
if service.PrivateNetworkInfo == nil {
return fmt.Errorf("Private network is required for exposed services")
}
port, err := service.PrivateNetworkInfo.Ports.SinglePort()
if err != nil {
return fmt.Errorf("Multi-port is not supported for exposed services: %s", err)
}
if service.PublicNetworkInfo != nil {
if _, err := service.PublicNetworkInfo.Ports.SinglePort(); err != nil {
return fmt.Errorf("Multi-port is not supported for public network services: %s", err)
}
}
// Find any existing state and get the authorizer. We do not want
// to re-initialize the authorizer for every policy update.
authProcessor, err := r.createOrUpdateAuthProcessor(sctx, service, secrets)
if err != nil {
return err
}
clientCAs := x509.NewCertPool()
if (service.UserAuthorizationType == policy.UserAuthorizationMutualTLS || service.UserAuthorizationType == policy.UserAuthorizationJWT) &&
len(service.MutualTLSTrustedRoots) > 0 {
if !clientCAs.AppendCertsFromPEM(service.MutualTLSTrustedRoots) {
return fmt.Errorf("Unable to process client CAs")
}
}
// Add the new references.
if err := r.indexByPort.Add(
service.PrivateNetworkInfo,
sctx.PU.ContextID,
&PortContext{
ID: sctx.PU.ContextID,
Service: service,
TargetPort: int(port),
Type: serviceTypeToNetworkListenerType(service.Type, false),
Authorizer: authProcessor,
ClientTrustedRoots: clientCAs,
PUContext: sctx.PUContext,
},
true,
); err != nil {
return fmt.Errorf("Possible port overlap: %s", err)
}
if service.Type == policy.ServiceHTTP && service.PublicNetworkInfo != nil {
if err := r.indexByPort.Add(
service.PublicNetworkInfo,
sctx.PU.ContextID,
&PortContext{
ID: sctx.PU.ContextID,
Service: service,
TargetPort: int(port),
Type: serviceTypeToNetworkListenerType(service.Type, service.PublicServiceNoTLS),
Authorizer: authProcessor,
ClientTrustedRoots: clientCAs,
PUContext: sctx.PUContext,
},
true,
); err != nil {
return fmt.Errorf("Possible port overlap with public services: %s", err)
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"updateExposedPortAssociations",
"(",
"sctx",
"*",
"ServiceContext",
",",
"service",
"*",
"policy",
".",
"ApplicationService",
",",
"secrets",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"// Do All the basic validations first.",
"if",
"service",
".",
"PrivateNetworkInfo",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"port",
",",
"err",
":=",
"service",
".",
"PrivateNetworkInfo",
".",
"Ports",
".",
"SinglePort",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"service",
".",
"PublicNetworkInfo",
"!=",
"nil",
"{",
"if",
"_",
",",
"err",
":=",
"service",
".",
"PublicNetworkInfo",
".",
"Ports",
".",
"SinglePort",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Find any existing state and get the authorizer. We do not want",
"// to re-initialize the authorizer for every policy update.",
"authProcessor",
",",
"err",
":=",
"r",
".",
"createOrUpdateAuthProcessor",
"(",
"sctx",
",",
"service",
",",
"secrets",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"clientCAs",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"if",
"(",
"service",
".",
"UserAuthorizationType",
"==",
"policy",
".",
"UserAuthorizationMutualTLS",
"||",
"service",
".",
"UserAuthorizationType",
"==",
"policy",
".",
"UserAuthorizationJWT",
")",
"&&",
"len",
"(",
"service",
".",
"MutualTLSTrustedRoots",
")",
">",
"0",
"{",
"if",
"!",
"clientCAs",
".",
"AppendCertsFromPEM",
"(",
"service",
".",
"MutualTLSTrustedRoots",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Add the new references.",
"if",
"err",
":=",
"r",
".",
"indexByPort",
".",
"Add",
"(",
"service",
".",
"PrivateNetworkInfo",
",",
"sctx",
".",
"PU",
".",
"ContextID",
",",
"&",
"PortContext",
"{",
"ID",
":",
"sctx",
".",
"PU",
".",
"ContextID",
",",
"Service",
":",
"service",
",",
"TargetPort",
":",
"int",
"(",
"port",
")",
",",
"Type",
":",
"serviceTypeToNetworkListenerType",
"(",
"service",
".",
"Type",
",",
"false",
")",
",",
"Authorizer",
":",
"authProcessor",
",",
"ClientTrustedRoots",
":",
"clientCAs",
",",
"PUContext",
":",
"sctx",
".",
"PUContext",
",",
"}",
",",
"true",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"service",
".",
"Type",
"==",
"policy",
".",
"ServiceHTTP",
"&&",
"service",
".",
"PublicNetworkInfo",
"!=",
"nil",
"{",
"if",
"err",
":=",
"r",
".",
"indexByPort",
".",
"Add",
"(",
"service",
".",
"PublicNetworkInfo",
",",
"sctx",
".",
"PU",
".",
"ContextID",
",",
"&",
"PortContext",
"{",
"ID",
":",
"sctx",
".",
"PU",
".",
"ContextID",
",",
"Service",
":",
"service",
",",
"TargetPort",
":",
"int",
"(",
"port",
")",
",",
"Type",
":",
"serviceTypeToNetworkListenerType",
"(",
"service",
".",
"Type",
",",
"service",
".",
"PublicServiceNoTLS",
")",
",",
"Authorizer",
":",
"authProcessor",
",",
"ClientTrustedRoots",
":",
"clientCAs",
",",
"PUContext",
":",
"sctx",
".",
"PUContext",
",",
"}",
",",
"true",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // updateExposedPortAssociations will insert the association between a port
// and a service in the global exposed service cache. This is needed
// for all incoming connections, so that can determine both the type
// of proxy as well the correct policy for this connection. This
// association cannot have overlaps. | [
"updateExposedPortAssociations",
"will",
"insert",
"the",
"association",
"between",
"a",
"port",
"and",
"a",
"service",
"in",
"the",
"global",
"exposed",
"service",
"cache",
".",
"This",
"is",
"needed",
"for",
"all",
"incoming",
"connections",
"so",
"that",
"can",
"determine",
"both",
"the",
"type",
"of",
"proxy",
"as",
"well",
"the",
"correct",
"policy",
"for",
"this",
"connection",
".",
"This",
"association",
"cannot",
"have",
"overlaps",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L179-L248 |
7,004 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | updateExposedServices | func (r *Registry) updateExposedServices(sctx *ServiceContext, secrets secrets.Secrets) error {
for _, service := range sctx.PU.Policy.ExposedServices() {
if service.Type != policy.ServiceHTTP && service.Type != policy.ServiceTCP {
continue
}
if err := r.updateExposedPortAssociations(sctx, service, secrets); err != nil {
return err
}
}
return nil
} | go | func (r *Registry) updateExposedServices(sctx *ServiceContext, secrets secrets.Secrets) error {
for _, service := range sctx.PU.Policy.ExposedServices() {
if service.Type != policy.ServiceHTTP && service.Type != policy.ServiceTCP {
continue
}
if err := r.updateExposedPortAssociations(sctx, service, secrets); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"updateExposedServices",
"(",
"sctx",
"*",
"ServiceContext",
",",
"secrets",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"for",
"_",
",",
"service",
":=",
"range",
"sctx",
".",
"PU",
".",
"Policy",
".",
"ExposedServices",
"(",
")",
"{",
"if",
"service",
".",
"Type",
"!=",
"policy",
".",
"ServiceHTTP",
"&&",
"service",
".",
"Type",
"!=",
"policy",
".",
"ServiceTCP",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"updateExposedPortAssociations",
"(",
"sctx",
",",
"service",
",",
"secrets",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // buildExposedServices builds the caches for the exposed services. It assumes that an authorization | [
"buildExposedServices",
"builds",
"the",
"caches",
"for",
"the",
"exposed",
"services",
".",
"It",
"assumes",
"that",
"an",
"authorization"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L251-L263 |
7,005 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | updateDependentServices | func (r *Registry) updateDependentServices(sctx *ServiceContext) error {
for _, service := range sctx.PU.Policy.DependentServices() {
if len(service.CACert) != 0 {
sctx.RootCA = append(sctx.RootCA, service.CACert)
}
serviceData := &DependentServiceData{
ServiceType: serviceTypeToApplicationListenerType(service.Type),
}
if service.Type == policy.ServiceHTTP {
serviceData.APICache = urisearch.NewAPICache(service.HTTPRules, service.ID, service.External)
}
if err := sctx.dependentServiceCache.Add(
service.NetworkInfo,
sctx.PU.ContextID,
serviceData,
false,
); err != nil {
return fmt.Errorf("Possible overlap in dependent services: %s", err)
}
}
return nil
} | go | func (r *Registry) updateDependentServices(sctx *ServiceContext) error {
for _, service := range sctx.PU.Policy.DependentServices() {
if len(service.CACert) != 0 {
sctx.RootCA = append(sctx.RootCA, service.CACert)
}
serviceData := &DependentServiceData{
ServiceType: serviceTypeToApplicationListenerType(service.Type),
}
if service.Type == policy.ServiceHTTP {
serviceData.APICache = urisearch.NewAPICache(service.HTTPRules, service.ID, service.External)
}
if err := sctx.dependentServiceCache.Add(
service.NetworkInfo,
sctx.PU.ContextID,
serviceData,
false,
); err != nil {
return fmt.Errorf("Possible overlap in dependent services: %s", err)
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"updateDependentServices",
"(",
"sctx",
"*",
"ServiceContext",
")",
"error",
"{",
"for",
"_",
",",
"service",
":=",
"range",
"sctx",
".",
"PU",
".",
"Policy",
".",
"DependentServices",
"(",
")",
"{",
"if",
"len",
"(",
"service",
".",
"CACert",
")",
"!=",
"0",
"{",
"sctx",
".",
"RootCA",
"=",
"append",
"(",
"sctx",
".",
"RootCA",
",",
"service",
".",
"CACert",
")",
"\n",
"}",
"\n\n",
"serviceData",
":=",
"&",
"DependentServiceData",
"{",
"ServiceType",
":",
"serviceTypeToApplicationListenerType",
"(",
"service",
".",
"Type",
")",
",",
"}",
"\n",
"if",
"service",
".",
"Type",
"==",
"policy",
".",
"ServiceHTTP",
"{",
"serviceData",
".",
"APICache",
"=",
"urisearch",
".",
"NewAPICache",
"(",
"service",
".",
"HTTPRules",
",",
"service",
".",
"ID",
",",
"service",
".",
"External",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"sctx",
".",
"dependentServiceCache",
".",
"Add",
"(",
"service",
".",
"NetworkInfo",
",",
"sctx",
".",
"PU",
".",
"ContextID",
",",
"serviceData",
",",
"false",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // updateDependentServices will update all the information in the
// ServiceContext for the dependent services. | [
"updateDependentServices",
"will",
"update",
"all",
"the",
"information",
"in",
"the",
"ServiceContext",
"for",
"the",
"dependent",
"services",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L267-L294 |
7,006 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/autoport.go | resync | func (d *Datapath) resync(newPortMap map[string]map[string]bool) {
iptablesInstance := iptablesctrl.GetInstance()
if iptablesInstance == nil {
return
}
for k, vs := range d.puToPortsMap {
m := newPortMap[k]
for v := range vs {
if m == nil || !m[v] {
err := iptablesInstance.DeletePortFromPortSet(k, v)
if err != nil {
zap.L().Debug("Delete port set returned error", zap.Error(err))
}
// delete the port from contextIDFromTCPPort cache
err = d.contextIDFromTCPPort.RemoveStringPorts(v)
if err != nil {
zap.L().Debug("can not remove port from cache", zap.Error(err))
}
}
}
}
for k, vs := range newPortMap {
m := d.puToPortsMap[k]
for v := range vs {
if m == nil || !m[v] {
portSpec, err := portspec.NewPortSpecFromString(v, k)
if err != nil {
continue
}
d.contextIDFromTCPPort.AddPortSpec(portSpec)
err = iptablesInstance.AddPortToPortSet(k, v)
if err != nil {
zap.L().Error("Failed to add port to portset", zap.String("context", k), zap.String("port", v))
}
}
}
}
d.puToPortsMap = newPortMap
} | go | func (d *Datapath) resync(newPortMap map[string]map[string]bool) {
iptablesInstance := iptablesctrl.GetInstance()
if iptablesInstance == nil {
return
}
for k, vs := range d.puToPortsMap {
m := newPortMap[k]
for v := range vs {
if m == nil || !m[v] {
err := iptablesInstance.DeletePortFromPortSet(k, v)
if err != nil {
zap.L().Debug("Delete port set returned error", zap.Error(err))
}
// delete the port from contextIDFromTCPPort cache
err = d.contextIDFromTCPPort.RemoveStringPorts(v)
if err != nil {
zap.L().Debug("can not remove port from cache", zap.Error(err))
}
}
}
}
for k, vs := range newPortMap {
m := d.puToPortsMap[k]
for v := range vs {
if m == nil || !m[v] {
portSpec, err := portspec.NewPortSpecFromString(v, k)
if err != nil {
continue
}
d.contextIDFromTCPPort.AddPortSpec(portSpec)
err = iptablesInstance.AddPortToPortSet(k, v)
if err != nil {
zap.L().Error("Failed to add port to portset", zap.String("context", k), zap.String("port", v))
}
}
}
}
d.puToPortsMap = newPortMap
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"resync",
"(",
"newPortMap",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"bool",
")",
"{",
"iptablesInstance",
":=",
"iptablesctrl",
".",
"GetInstance",
"(",
")",
"\n",
"if",
"iptablesInstance",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"vs",
":=",
"range",
"d",
".",
"puToPortsMap",
"{",
"m",
":=",
"newPortMap",
"[",
"k",
"]",
"\n\n",
"for",
"v",
":=",
"range",
"vs",
"{",
"if",
"m",
"==",
"nil",
"||",
"!",
"m",
"[",
"v",
"]",
"{",
"err",
":=",
"iptablesInstance",
".",
"DeletePortFromPortSet",
"(",
"k",
",",
"v",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"// delete the port from contextIDFromTCPPort cache",
"err",
"=",
"d",
".",
"contextIDFromTCPPort",
".",
"RemoveStringPorts",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"vs",
":=",
"range",
"newPortMap",
"{",
"m",
":=",
"d",
".",
"puToPortsMap",
"[",
"k",
"]",
"\n",
"for",
"v",
":=",
"range",
"vs",
"{",
"if",
"m",
"==",
"nil",
"||",
"!",
"m",
"[",
"v",
"]",
"{",
"portSpec",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"v",
",",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"d",
".",
"contextIDFromTCPPort",
".",
"AddPortSpec",
"(",
"portSpec",
")",
"\n",
"err",
"=",
"iptablesInstance",
".",
"AddPortToPortSet",
"(",
"k",
",",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"k",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"d",
".",
"puToPortsMap",
"=",
"newPortMap",
"\n",
"}"
] | // resync adds new port for the PU and removes the stale ports | [
"resync",
"adds",
"new",
"port",
"for",
"the",
"PU",
"and",
"removes",
"the",
"stale",
"ports"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/autoport.go#L70-L113 |
7,007 | aporeto-inc/trireme-lib | controller/pkg/usertokens/common/common.go | FlattenClaim | func FlattenClaim(key string, claim interface{}) []string {
attributes := []string{}
if slice, ok := claim.([]string); ok {
for _, data := range slice {
attributes = append(attributes, key+"="+data)
}
}
if attr, ok := claim.(string); ok {
attributes = append(attributes, key+"="+attr)
}
if kv, ok := claim.(map[string]interface{}); ok {
for ikey, ivalue := range kv {
if attr, ok := ivalue.(string); ok {
attributes = append(attributes, key+":"+ikey+"="+attr)
}
}
}
return attributes
} | go | func FlattenClaim(key string, claim interface{}) []string {
attributes := []string{}
if slice, ok := claim.([]string); ok {
for _, data := range slice {
attributes = append(attributes, key+"="+data)
}
}
if attr, ok := claim.(string); ok {
attributes = append(attributes, key+"="+attr)
}
if kv, ok := claim.(map[string]interface{}); ok {
for ikey, ivalue := range kv {
if attr, ok := ivalue.(string); ok {
attributes = append(attributes, key+":"+ikey+"="+attr)
}
}
}
return attributes
} | [
"func",
"FlattenClaim",
"(",
"key",
"string",
",",
"claim",
"interface",
"{",
"}",
")",
"[",
"]",
"string",
"{",
"attributes",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"if",
"slice",
",",
"ok",
":=",
"claim",
".",
"(",
"[",
"]",
"string",
")",
";",
"ok",
"{",
"for",
"_",
",",
"data",
":=",
"range",
"slice",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"key",
"+",
"\"",
"\"",
"+",
"data",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"attr",
",",
"ok",
":=",
"claim",
".",
"(",
"string",
")",
";",
"ok",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"key",
"+",
"\"",
"\"",
"+",
"attr",
")",
"\n",
"}",
"\n",
"if",
"kv",
",",
"ok",
":=",
"claim",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"for",
"ikey",
",",
"ivalue",
":=",
"range",
"kv",
"{",
"if",
"attr",
",",
"ok",
":=",
"ivalue",
".",
"(",
"string",
")",
";",
"ok",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"key",
"+",
"\"",
"\"",
"+",
"ikey",
"+",
"\"",
"\"",
"+",
"attr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"attributes",
"\n",
"}"
] | // FlattenClaim flattes all the generic claims in a flat array for strings. | [
"FlattenClaim",
"flattes",
"all",
"the",
"generic",
"claims",
"in",
"a",
"flat",
"array",
"for",
"strings",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/usertokens/common/common.go#L13-L31 |
7,008 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | SetupConfig | func (d *DockerMonitor) SetupConfig(registerer registerer.Registerer, cfg interface{}) (err error) {
defaultConfig := DefaultConfig()
if cfg == nil {
cfg = defaultConfig
}
dockerConfig, ok := cfg.(*Config)
if !ok {
return fmt.Errorf("Invalid configuration specified")
}
// Setup defaults
dockerConfig = SetupDefaultConfig(dockerConfig)
d.socketType = dockerConfig.SocketType
d.socketAddress = dockerConfig.SocketAddress
d.metadataExtractor = dockerConfig.EventMetadataExtractor
d.syncAtStart = dockerConfig.SyncAtStart
d.killContainerOnPolicyError = dockerConfig.KillContainerOnPolicyError
d.handlers = make(map[Event]func(ctx context.Context, event *events.Message) error)
d.stoplistener = make(chan bool)
d.netcls = cgnetcls.NewDockerCgroupNetController()
d.numberOfQueues = runtime.NumCPU() * 8
d.eventnotifications = make([]chan *events.Message, d.numberOfQueues)
d.stopprocessor = make([]chan bool, d.numberOfQueues)
for i := 0; i < d.numberOfQueues; i++ {
d.eventnotifications[i] = make(chan *events.Message, 1000)
d.stopprocessor[i] = make(chan bool)
}
// Add handlers for the events that we know how to process
d.addHandler(EventCreate, d.handleCreateEvent)
d.addHandler(EventStart, d.handleStartEvent)
d.addHandler(EventDie, d.handleDieEvent)
d.addHandler(EventDestroy, d.handleDestroyEvent)
d.addHandler(EventPause, d.handlePauseEvent)
d.addHandler(EventUnpause, d.handleUnpauseEvent)
return nil
} | go | func (d *DockerMonitor) SetupConfig(registerer registerer.Registerer, cfg interface{}) (err error) {
defaultConfig := DefaultConfig()
if cfg == nil {
cfg = defaultConfig
}
dockerConfig, ok := cfg.(*Config)
if !ok {
return fmt.Errorf("Invalid configuration specified")
}
// Setup defaults
dockerConfig = SetupDefaultConfig(dockerConfig)
d.socketType = dockerConfig.SocketType
d.socketAddress = dockerConfig.SocketAddress
d.metadataExtractor = dockerConfig.EventMetadataExtractor
d.syncAtStart = dockerConfig.SyncAtStart
d.killContainerOnPolicyError = dockerConfig.KillContainerOnPolicyError
d.handlers = make(map[Event]func(ctx context.Context, event *events.Message) error)
d.stoplistener = make(chan bool)
d.netcls = cgnetcls.NewDockerCgroupNetController()
d.numberOfQueues = runtime.NumCPU() * 8
d.eventnotifications = make([]chan *events.Message, d.numberOfQueues)
d.stopprocessor = make([]chan bool, d.numberOfQueues)
for i := 0; i < d.numberOfQueues; i++ {
d.eventnotifications[i] = make(chan *events.Message, 1000)
d.stopprocessor[i] = make(chan bool)
}
// Add handlers for the events that we know how to process
d.addHandler(EventCreate, d.handleCreateEvent)
d.addHandler(EventStart, d.handleStartEvent)
d.addHandler(EventDie, d.handleDieEvent)
d.addHandler(EventDestroy, d.handleDestroyEvent)
d.addHandler(EventPause, d.handlePauseEvent)
d.addHandler(EventUnpause, d.handleUnpauseEvent)
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"SetupConfig",
"(",
"registerer",
"registerer",
".",
"Registerer",
",",
"cfg",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"defaultConfig",
":=",
"DefaultConfig",
"(",
")",
"\n\n",
"if",
"cfg",
"==",
"nil",
"{",
"cfg",
"=",
"defaultConfig",
"\n",
"}",
"\n\n",
"dockerConfig",
",",
"ok",
":=",
"cfg",
".",
"(",
"*",
"Config",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Setup defaults",
"dockerConfig",
"=",
"SetupDefaultConfig",
"(",
"dockerConfig",
")",
"\n\n",
"d",
".",
"socketType",
"=",
"dockerConfig",
".",
"SocketType",
"\n",
"d",
".",
"socketAddress",
"=",
"dockerConfig",
".",
"SocketAddress",
"\n",
"d",
".",
"metadataExtractor",
"=",
"dockerConfig",
".",
"EventMetadataExtractor",
"\n",
"d",
".",
"syncAtStart",
"=",
"dockerConfig",
".",
"SyncAtStart",
"\n",
"d",
".",
"killContainerOnPolicyError",
"=",
"dockerConfig",
".",
"KillContainerOnPolicyError",
"\n",
"d",
".",
"handlers",
"=",
"make",
"(",
"map",
"[",
"Event",
"]",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
")",
"\n",
"d",
".",
"stoplistener",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"d",
".",
"netcls",
"=",
"cgnetcls",
".",
"NewDockerCgroupNetController",
"(",
")",
"\n",
"d",
".",
"numberOfQueues",
"=",
"runtime",
".",
"NumCPU",
"(",
")",
"*",
"8",
"\n",
"d",
".",
"eventnotifications",
"=",
"make",
"(",
"[",
"]",
"chan",
"*",
"events",
".",
"Message",
",",
"d",
".",
"numberOfQueues",
")",
"\n",
"d",
".",
"stopprocessor",
"=",
"make",
"(",
"[",
"]",
"chan",
"bool",
",",
"d",
".",
"numberOfQueues",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"d",
".",
"numberOfQueues",
";",
"i",
"++",
"{",
"d",
".",
"eventnotifications",
"[",
"i",
"]",
"=",
"make",
"(",
"chan",
"*",
"events",
".",
"Message",
",",
"1000",
")",
"\n",
"d",
".",
"stopprocessor",
"[",
"i",
"]",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"}",
"\n\n",
"// Add handlers for the events that we know how to process",
"d",
".",
"addHandler",
"(",
"EventCreate",
",",
"d",
".",
"handleCreateEvent",
")",
"\n",
"d",
".",
"addHandler",
"(",
"EventStart",
",",
"d",
".",
"handleStartEvent",
")",
"\n",
"d",
".",
"addHandler",
"(",
"EventDie",
",",
"d",
".",
"handleDieEvent",
")",
"\n",
"d",
".",
"addHandler",
"(",
"EventDestroy",
",",
"d",
".",
"handleDestroyEvent",
")",
"\n",
"d",
".",
"addHandler",
"(",
"EventPause",
",",
"d",
".",
"handlePauseEvent",
")",
"\n",
"d",
".",
"addHandler",
"(",
"EventUnpause",
",",
"d",
".",
"handleUnpauseEvent",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SetupConfig provides a configuration to implmentations. Every implementation
// can have its own config type. | [
"SetupConfig",
"provides",
"a",
"configuration",
"to",
"implmentations",
".",
"Every",
"implementation",
"can",
"have",
"its",
"own",
"config",
"type",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L55-L96 |
7,009 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | Run | func (d *DockerMonitor) Run(ctx context.Context) error {
if err := d.config.IsComplete(); err != nil {
return fmt.Errorf("docker: %s", err)
}
err := d.waitForDockerDaemon(ctx)
if err != nil {
zap.L().Error("Docker daemon is not running - skipping container processing", zap.Error(err))
return nil
}
if d.syncAtStart && d.config.Policy != nil {
options := types.ContainerListOptions{All: true}
containers, err := d.dockerClient.ContainerList(ctx, options)
if err != nil {
return fmt.Errorf("unable to get container list: %s", err)
}
// Starting the eventListener and wait to hear on channel for it to be ready.
// Need to start before the resync process so that we don't loose any events.
// They will be buffered. We don't want to start the listener before
// getting the list from docker though, to avoid duplicates.
listenerReady := make(chan struct{})
go d.eventListener(ctx, listenerReady)
<-listenerReady
zap.L().Debug("Syncing all existing containers")
// Syncing all Existing containers depending on MonitorSetting
if err := d.resyncContainers(ctx, containers); err != nil {
zap.L().Error("Unable to sync existing containers", zap.Error(err))
}
} else {
// Starting the eventListener and wait to hear on channel for it to be ready.
// We are not doing resync. We just start the listener.
listenerReady := make(chan struct{})
go d.eventListener(ctx, listenerReady)
<-listenerReady
}
// Start processing the events
go d.eventProcessors(ctx)
return nil
} | go | func (d *DockerMonitor) Run(ctx context.Context) error {
if err := d.config.IsComplete(); err != nil {
return fmt.Errorf("docker: %s", err)
}
err := d.waitForDockerDaemon(ctx)
if err != nil {
zap.L().Error("Docker daemon is not running - skipping container processing", zap.Error(err))
return nil
}
if d.syncAtStart && d.config.Policy != nil {
options := types.ContainerListOptions{All: true}
containers, err := d.dockerClient.ContainerList(ctx, options)
if err != nil {
return fmt.Errorf("unable to get container list: %s", err)
}
// Starting the eventListener and wait to hear on channel for it to be ready.
// Need to start before the resync process so that we don't loose any events.
// They will be buffered. We don't want to start the listener before
// getting the list from docker though, to avoid duplicates.
listenerReady := make(chan struct{})
go d.eventListener(ctx, listenerReady)
<-listenerReady
zap.L().Debug("Syncing all existing containers")
// Syncing all Existing containers depending on MonitorSetting
if err := d.resyncContainers(ctx, containers); err != nil {
zap.L().Error("Unable to sync existing containers", zap.Error(err))
}
} else {
// Starting the eventListener and wait to hear on channel for it to be ready.
// We are not doing resync. We just start the listener.
listenerReady := make(chan struct{})
go d.eventListener(ctx, listenerReady)
<-listenerReady
}
// Start processing the events
go d.eventProcessors(ctx)
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"config",
".",
"IsComplete",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"d",
".",
"waitForDockerDaemon",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"d",
".",
"syncAtStart",
"&&",
"d",
".",
"config",
".",
"Policy",
"!=",
"nil",
"{",
"options",
":=",
"types",
".",
"ContainerListOptions",
"{",
"All",
":",
"true",
"}",
"\n",
"containers",
",",
"err",
":=",
"d",
".",
"dockerClient",
".",
"ContainerList",
"(",
"ctx",
",",
"options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Starting the eventListener and wait to hear on channel for it to be ready.",
"// Need to start before the resync process so that we don't loose any events.",
"// They will be buffered. We don't want to start the listener before",
"// getting the list from docker though, to avoid duplicates.",
"listenerReady",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"go",
"d",
".",
"eventListener",
"(",
"ctx",
",",
"listenerReady",
")",
"\n",
"<-",
"listenerReady",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"// Syncing all Existing containers depending on MonitorSetting",
"if",
"err",
":=",
"d",
".",
"resyncContainers",
"(",
"ctx",
",",
"containers",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Starting the eventListener and wait to hear on channel for it to be ready.",
"// We are not doing resync. We just start the listener.",
"listenerReady",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"go",
"d",
".",
"eventListener",
"(",
"ctx",
",",
"listenerReady",
")",
"\n",
"<-",
"listenerReady",
"\n",
"}",
"\n\n",
"// Start processing the events",
"go",
"d",
".",
"eventProcessors",
"(",
"ctx",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Run will start the DockerPolicy Enforcement.
// It applies a policy to each Container already Up and Running.
// It listens to all ContainerEvents | [
"Run",
"will",
"start",
"the",
"DockerPolicy",
"Enforcement",
".",
"It",
"applies",
"a",
"policy",
"to",
"each",
"Container",
"already",
"Up",
"and",
"Running",
".",
"It",
"listens",
"to",
"all",
"ContainerEvents"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L109-L154 |
7,010 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | sendRequestToQueue | func (d *DockerMonitor) sendRequestToQueue(r *events.Message) {
key0 := uint64(256203161)
key1 := uint64(982451653)
key := d.getHashKey(r)
h := siphash.Hash(key0, key1, []byte(key))
d.eventnotifications[int(h%uint64(d.numberOfQueues))] <- r
} | go | func (d *DockerMonitor) sendRequestToQueue(r *events.Message) {
key0 := uint64(256203161)
key1 := uint64(982451653)
key := d.getHashKey(r)
h := siphash.Hash(key0, key1, []byte(key))
d.eventnotifications[int(h%uint64(d.numberOfQueues))] <- r
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"sendRequestToQueue",
"(",
"r",
"*",
"events",
".",
"Message",
")",
"{",
"key0",
":=",
"uint64",
"(",
"256203161",
")",
"\n",
"key1",
":=",
"uint64",
"(",
"982451653",
")",
"\n\n",
"key",
":=",
"d",
".",
"getHashKey",
"(",
"r",
")",
"\n",
"h",
":=",
"siphash",
".",
"Hash",
"(",
"key0",
",",
"key1",
",",
"[",
"]",
"byte",
"(",
"key",
")",
")",
"\n\n",
"d",
".",
"eventnotifications",
"[",
"int",
"(",
"h",
"%",
"uint64",
"(",
"d",
".",
"numberOfQueues",
")",
")",
"]",
"<-",
"r",
"\n",
"}"
] | // sendRequestToQueue sends a request to a channel based on a hash function | [
"sendRequestToQueue",
"sends",
"a",
"request",
"to",
"a",
"channel",
"based",
"on",
"a",
"hash",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L175-L184 |
7,011 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | eventProcessors | func (d *DockerMonitor) eventProcessors(ctx context.Context) {
for i := 0; i < d.numberOfQueues; i++ {
go func(i int) {
for {
select {
case event := <-d.eventnotifications[i]:
if f, ok := d.handlers[Event(event.Action)]; ok {
if err := f(ctx, event); err != nil {
zap.L().Error("Unable to handle docker event",
zap.String("action", event.Action),
zap.Error(err),
)
}
continue
}
case <-ctx.Done():
return
}
}
}(i)
}
} | go | func (d *DockerMonitor) eventProcessors(ctx context.Context) {
for i := 0; i < d.numberOfQueues; i++ {
go func(i int) {
for {
select {
case event := <-d.eventnotifications[i]:
if f, ok := d.handlers[Event(event.Action)]; ok {
if err := f(ctx, event); err != nil {
zap.L().Error("Unable to handle docker event",
zap.String("action", event.Action),
zap.Error(err),
)
}
continue
}
case <-ctx.Done():
return
}
}
}(i)
}
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"eventProcessors",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"d",
".",
"numberOfQueues",
";",
"i",
"++",
"{",
"go",
"func",
"(",
"i",
"int",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"event",
":=",
"<-",
"d",
".",
"eventnotifications",
"[",
"i",
"]",
":",
"if",
"f",
",",
"ok",
":=",
"d",
".",
"handlers",
"[",
"Event",
"(",
"event",
".",
"Action",
")",
"]",
";",
"ok",
"{",
"if",
"err",
":=",
"f",
"(",
"ctx",
",",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"event",
".",
"Action",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
"i",
")",
"\n",
"}",
"\n",
"}"
] | // eventProcessor processes docker events. We are processing multiple
// queues in parallel so that we can activate containers as fast
// as possible. | [
"eventProcessor",
"processes",
"docker",
"events",
".",
"We",
"are",
"processing",
"multiple",
"queues",
"in",
"parallel",
"so",
"that",
"we",
"can",
"activate",
"containers",
"as",
"fast",
"as",
"possible",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L189-L211 |
7,012 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | eventListener | func (d *DockerMonitor) eventListener(ctx context.Context, listenerReady chan struct{}) {
f := filters.NewArgs()
f.Add("type", "container")
options := types.EventsOptions{
Filters: f,
}
messages, errs := d.dockerClient.Events(context.Background(), options)
// Once the buffered event channel was returned by Docker we return the ready status.
listenerReady <- struct{}{}
for {
select {
case message := <-messages:
zap.L().Debug("Got message from docker client",
zap.String("action", message.Action),
zap.String("ID", message.ID),
)
d.sendRequestToQueue(&message)
case err := <-errs:
if err != nil && err != io.EOF {
zap.L().Warn("Received docker event error",
zap.Error(err),
)
}
case <-ctx.Done():
return
}
}
} | go | func (d *DockerMonitor) eventListener(ctx context.Context, listenerReady chan struct{}) {
f := filters.NewArgs()
f.Add("type", "container")
options := types.EventsOptions{
Filters: f,
}
messages, errs := d.dockerClient.Events(context.Background(), options)
// Once the buffered event channel was returned by Docker we return the ready status.
listenerReady <- struct{}{}
for {
select {
case message := <-messages:
zap.L().Debug("Got message from docker client",
zap.String("action", message.Action),
zap.String("ID", message.ID),
)
d.sendRequestToQueue(&message)
case err := <-errs:
if err != nil && err != io.EOF {
zap.L().Warn("Received docker event error",
zap.Error(err),
)
}
case <-ctx.Done():
return
}
}
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"eventListener",
"(",
"ctx",
"context",
".",
"Context",
",",
"listenerReady",
"chan",
"struct",
"{",
"}",
")",
"{",
"f",
":=",
"filters",
".",
"NewArgs",
"(",
")",
"\n",
"f",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"options",
":=",
"types",
".",
"EventsOptions",
"{",
"Filters",
":",
"f",
",",
"}",
"\n\n",
"messages",
",",
"errs",
":=",
"d",
".",
"dockerClient",
".",
"Events",
"(",
"context",
".",
"Background",
"(",
")",
",",
"options",
")",
"\n\n",
"// Once the buffered event channel was returned by Docker we return the ready status.",
"listenerReady",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"message",
":=",
"<-",
"messages",
":",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"message",
".",
"Action",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"message",
".",
"ID",
")",
",",
")",
"\n",
"d",
".",
"sendRequestToQueue",
"(",
"&",
"message",
")",
"\n\n",
"case",
"err",
":=",
"<-",
"errs",
":",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // eventListener listens to Docker events from the daemon and passes to
// to the processor through a buffered channel. This minimizes the chances
// that we will miss events because the processor is delayed | [
"eventListener",
"listens",
"to",
"Docker",
"events",
"from",
"the",
"daemon",
"and",
"passes",
"to",
"to",
"the",
"processor",
"through",
"a",
"buffered",
"channel",
".",
"This",
"minimizes",
"the",
"chances",
"that",
"we",
"will",
"miss",
"events",
"because",
"the",
"processor",
"is",
"delayed"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L216-L248 |
7,013 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | Resync | func (d *DockerMonitor) Resync(ctx context.Context) error {
if !d.syncAtStart || d.config.Policy == nil {
zap.L().Debug("No synchronization of containers performed")
return nil
}
zap.L().Debug("Syncing all existing containers")
options := types.ContainerListOptions{All: true}
containers, err := d.dockerClient.ContainerList(ctx, options)
if err != nil {
return fmt.Errorf("unable to get container list: %s", err)
}
return d.resyncContainers(ctx, containers)
} | go | func (d *DockerMonitor) Resync(ctx context.Context) error {
if !d.syncAtStart || d.config.Policy == nil {
zap.L().Debug("No synchronization of containers performed")
return nil
}
zap.L().Debug("Syncing all existing containers")
options := types.ContainerListOptions{All: true}
containers, err := d.dockerClient.ContainerList(ctx, options)
if err != nil {
return fmt.Errorf("unable to get container list: %s", err)
}
return d.resyncContainers(ctx, containers)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"Resync",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"!",
"d",
".",
"syncAtStart",
"||",
"d",
".",
"config",
".",
"Policy",
"==",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"options",
":=",
"types",
".",
"ContainerListOptions",
"{",
"All",
":",
"true",
"}",
"\n",
"containers",
",",
"err",
":=",
"d",
".",
"dockerClient",
".",
"ContainerList",
"(",
"ctx",
",",
"options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"resyncContainers",
"(",
"ctx",
",",
"containers",
")",
"\n",
"}"
] | // Resync resyncs all the existing containers on the Host, using the
// same process as when a container is initially spawn up | [
"Resync",
"resyncs",
"all",
"the",
"existing",
"containers",
"on",
"the",
"Host",
"using",
"the",
"same",
"process",
"as",
"when",
"a",
"container",
"is",
"initially",
"spawn",
"up"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L252-L268 |
7,014 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | resyncContainersByOrder | func (d *DockerMonitor) resyncContainersByOrder(ctx context.Context, containers []types.Container, syncHost bool) error {
for _, c := range containers {
container, err := d.dockerClient.ContainerInspect(ctx, c.ID)
if err != nil {
continue
}
if (syncHost && container.HostConfig.NetworkMode != constants.DockerHostMode) ||
(!syncHost && container.HostConfig.NetworkMode == constants.DockerHostMode) {
continue
}
puID, _ := puIDFromDockerID(container.ID)
runtime, err := d.extractMetadata(&container)
if err != nil {
continue
}
event := common.EventStop
if container.State.Running {
if !container.State.Paused {
event = common.EventStart
} else {
event = common.EventPause
}
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(&container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
if err := d.config.Policy.HandlePUEvent(ctx, puID, event, runtime); err != nil {
zap.L().Error("Unable to sync existing Container",
zap.String("dockerID", c.ID),
zap.Error(err),
)
}
// if the container has hostnet set to true or is linked
// to container with hostnet set to true, program the cgroup.
if isHostNetworkContainer(runtime) {
if err = d.setupHostMode(puID, runtime, &container); err != nil {
return fmt.Errorf("unable to setup host mode for container %s: %s", puID, err)
}
}
}
return nil
} | go | func (d *DockerMonitor) resyncContainersByOrder(ctx context.Context, containers []types.Container, syncHost bool) error {
for _, c := range containers {
container, err := d.dockerClient.ContainerInspect(ctx, c.ID)
if err != nil {
continue
}
if (syncHost && container.HostConfig.NetworkMode != constants.DockerHostMode) ||
(!syncHost && container.HostConfig.NetworkMode == constants.DockerHostMode) {
continue
}
puID, _ := puIDFromDockerID(container.ID)
runtime, err := d.extractMetadata(&container)
if err != nil {
continue
}
event := common.EventStop
if container.State.Running {
if !container.State.Paused {
event = common.EventStart
} else {
event = common.EventPause
}
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(&container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
if err := d.config.Policy.HandlePUEvent(ctx, puID, event, runtime); err != nil {
zap.L().Error("Unable to sync existing Container",
zap.String("dockerID", c.ID),
zap.Error(err),
)
}
// if the container has hostnet set to true or is linked
// to container with hostnet set to true, program the cgroup.
if isHostNetworkContainer(runtime) {
if err = d.setupHostMode(puID, runtime, &container); err != nil {
return fmt.Errorf("unable to setup host mode for container %s: %s", puID, err)
}
}
}
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"resyncContainersByOrder",
"(",
"ctx",
"context",
".",
"Context",
",",
"containers",
"[",
"]",
"types",
".",
"Container",
",",
"syncHost",
"bool",
")",
"error",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"containers",
"{",
"container",
",",
"err",
":=",
"d",
".",
"dockerClient",
".",
"ContainerInspect",
"(",
"ctx",
",",
"c",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"(",
"syncHost",
"&&",
"container",
".",
"HostConfig",
".",
"NetworkMode",
"!=",
"constants",
".",
"DockerHostMode",
")",
"||",
"(",
"!",
"syncHost",
"&&",
"container",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"puID",
",",
"_",
":=",
"puIDFromDockerID",
"(",
"container",
".",
"ID",
")",
"\n\n",
"runtime",
",",
"err",
":=",
"d",
".",
"extractMetadata",
"(",
"&",
"container",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"event",
":=",
"common",
".",
"EventStop",
"\n",
"if",
"container",
".",
"State",
".",
"Running",
"{",
"if",
"!",
"container",
".",
"State",
".",
"Paused",
"{",
"event",
"=",
"common",
".",
"EventStart",
"\n",
"}",
"else",
"{",
"event",
"=",
"common",
".",
"EventPause",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If it is a host container, we need to activate it as a Linux process. We will",
"// override the options that the metadata extractor provided.",
"if",
"container",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
"{",
"options",
":=",
"hostModeOptions",
"(",
"&",
"container",
")",
"\n",
"options",
".",
"PolicyExtensions",
"=",
"runtime",
".",
"Options",
"(",
")",
".",
"PolicyExtensions",
"\n",
"runtime",
".",
"SetOptions",
"(",
"*",
"options",
")",
"\n",
"runtime",
".",
"SetPUType",
"(",
"common",
".",
"LinuxProcessPU",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"if",
"err",
":=",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"event",
",",
"runtime",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"c",
".",
"ID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"// if the container has hostnet set to true or is linked",
"// to container with hostnet set to true, program the cgroup.",
"if",
"isHostNetworkContainer",
"(",
"runtime",
")",
"{",
"if",
"err",
"=",
"d",
".",
"setupHostMode",
"(",
"puID",
",",
"runtime",
",",
"&",
"container",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"puID",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //container.HostConfig.NetworkMode == constants.DockerHostMode | [
"container",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L286-L343 |
7,015 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | setupHostMode | func (d *DockerMonitor) setupHostMode(puID string, runtimeInfo policy.RuntimeReader, dockerInfo *types.ContainerJSON) (err error) {
pausePUID := puID
if dockerInfo.HostConfig.NetworkMode == constants.DockerHostMode {
if err = d.netcls.Creategroup(puID); err != nil {
return err
}
// Clean the cgroup on exit, if we have failed t activate.
defer func() {
if err != nil {
if derr := d.netcls.DeleteCgroup(puID); derr != nil {
zap.L().Warn("Failed to clean cgroup",
zap.String("puID", puID),
zap.Error(derr),
zap.Error(err),
)
}
}
}()
markval := runtimeInfo.Options().CgroupMark
if markval == "" {
return errors.New("mark value not found")
}
mark, _ := strconv.ParseUint(markval, 10, 32)
if err := d.netcls.AssignMark(puID, mark); err != nil {
return err
}
} else {
// Add the container pid that is linked to hostnet to
// the cgroup of the parent container.
pausePUID = getPausePUID(policyExtensions(runtimeInfo))
}
return d.netcls.AddProcess(pausePUID, dockerInfo.State.Pid)
} | go | func (d *DockerMonitor) setupHostMode(puID string, runtimeInfo policy.RuntimeReader, dockerInfo *types.ContainerJSON) (err error) {
pausePUID := puID
if dockerInfo.HostConfig.NetworkMode == constants.DockerHostMode {
if err = d.netcls.Creategroup(puID); err != nil {
return err
}
// Clean the cgroup on exit, if we have failed t activate.
defer func() {
if err != nil {
if derr := d.netcls.DeleteCgroup(puID); derr != nil {
zap.L().Warn("Failed to clean cgroup",
zap.String("puID", puID),
zap.Error(derr),
zap.Error(err),
)
}
}
}()
markval := runtimeInfo.Options().CgroupMark
if markval == "" {
return errors.New("mark value not found")
}
mark, _ := strconv.ParseUint(markval, 10, 32)
if err := d.netcls.AssignMark(puID, mark); err != nil {
return err
}
} else {
// Add the container pid that is linked to hostnet to
// the cgroup of the parent container.
pausePUID = getPausePUID(policyExtensions(runtimeInfo))
}
return d.netcls.AddProcess(pausePUID, dockerInfo.State.Pid)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"setupHostMode",
"(",
"puID",
"string",
",",
"runtimeInfo",
"policy",
".",
"RuntimeReader",
",",
"dockerInfo",
"*",
"types",
".",
"ContainerJSON",
")",
"(",
"err",
"error",
")",
"{",
"pausePUID",
":=",
"puID",
"\n",
"if",
"dockerInfo",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
"{",
"if",
"err",
"=",
"d",
".",
"netcls",
".",
"Creategroup",
"(",
"puID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Clean the cgroup on exit, if we have failed t activate.",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"if",
"derr",
":=",
"d",
".",
"netcls",
".",
"DeleteCgroup",
"(",
"puID",
")",
";",
"derr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"puID",
")",
",",
"zap",
".",
"Error",
"(",
"derr",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"markval",
":=",
"runtimeInfo",
".",
"Options",
"(",
")",
".",
"CgroupMark",
"\n",
"if",
"markval",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"mark",
",",
"_",
":=",
"strconv",
".",
"ParseUint",
"(",
"markval",
",",
"10",
",",
"32",
")",
"\n",
"if",
"err",
":=",
"d",
".",
"netcls",
".",
"AssignMark",
"(",
"puID",
",",
"mark",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Add the container pid that is linked to hostnet to",
"// the cgroup of the parent container.",
"pausePUID",
"=",
"getPausePUID",
"(",
"policyExtensions",
"(",
"runtimeInfo",
")",
")",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"netcls",
".",
"AddProcess",
"(",
"pausePUID",
",",
"dockerInfo",
".",
"State",
".",
"Pid",
")",
"\n",
"}"
] | // setupHostMode sets up the net_cls cgroup for the host mode | [
"setupHostMode",
"sets",
"up",
"the",
"net_cls",
"cgroup",
"for",
"the",
"host",
"mode"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L346-L384 |
7,016 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | extractMetadata | func (d *DockerMonitor) extractMetadata(dockerInfo *types.ContainerJSON) (*policy.PURuntime, error) {
if dockerInfo == nil {
return nil, errors.New("docker info is empty")
}
if d.metadataExtractor != nil {
return d.metadataExtractor(dockerInfo)
}
return extractors.DefaultMetadataExtractor(dockerInfo)
} | go | func (d *DockerMonitor) extractMetadata(dockerInfo *types.ContainerJSON) (*policy.PURuntime, error) {
if dockerInfo == nil {
return nil, errors.New("docker info is empty")
}
if d.metadataExtractor != nil {
return d.metadataExtractor(dockerInfo)
}
return extractors.DefaultMetadataExtractor(dockerInfo)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"extractMetadata",
"(",
"dockerInfo",
"*",
"types",
".",
"ContainerJSON",
")",
"(",
"*",
"policy",
".",
"PURuntime",
",",
"error",
")",
"{",
"if",
"dockerInfo",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"d",
".",
"metadataExtractor",
"!=",
"nil",
"{",
"return",
"d",
".",
"metadataExtractor",
"(",
"dockerInfo",
")",
"\n",
"}",
"\n\n",
"return",
"extractors",
".",
"DefaultMetadataExtractor",
"(",
"dockerInfo",
")",
"\n",
"}"
] | // ExtractMetadata generates the RuntimeInfo based on Docker primitive | [
"ExtractMetadata",
"generates",
"the",
"RuntimeInfo",
"based",
"on",
"Docker",
"primitive"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L413-L424 |
7,017 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | handleCreateEvent | func (d *DockerMonitor) handleCreateEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
container, err := d.retrieveDockerInfo(ctx, event)
if err != nil {
return err
}
runtime, err := d.extractMetadata(container)
if err != nil {
return err
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided. We will maintain
// any policy extensions in the object.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventCreate, runtime)
} | go | func (d *DockerMonitor) handleCreateEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
container, err := d.retrieveDockerInfo(ctx, event)
if err != nil {
return err
}
runtime, err := d.extractMetadata(container)
if err != nil {
return err
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided. We will maintain
// any policy extensions in the object.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventCreate, runtime)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"handleCreateEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
"{",
"puID",
",",
"err",
":=",
"puIDFromDockerID",
"(",
"event",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"container",
",",
"err",
":=",
"d",
".",
"retrieveDockerInfo",
"(",
"ctx",
",",
"event",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"runtime",
",",
"err",
":=",
"d",
".",
"extractMetadata",
"(",
"container",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// If it is a host container, we need to activate it as a Linux process. We will",
"// override the options that the metadata extractor provided. We will maintain",
"// any policy extensions in the object.",
"if",
"container",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
"{",
"options",
":=",
"hostModeOptions",
"(",
"container",
")",
"\n",
"options",
".",
"PolicyExtensions",
"=",
"runtime",
".",
"Options",
"(",
")",
".",
"PolicyExtensions",
"\n",
"runtime",
".",
"SetOptions",
"(",
"*",
"options",
")",
"\n",
"runtime",
".",
"SetPUType",
"(",
"common",
".",
"LinuxProcessPU",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"return",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"tevents",
".",
"EventCreate",
",",
"runtime",
")",
"\n",
"}"
] | // handleCreateEvent generates a create event type. We extract the metadata
// and start the policy resolution at the create event. No need to wait
// for the start event. | [
"handleCreateEvent",
"generates",
"a",
"create",
"event",
"type",
".",
"We",
"extract",
"the",
"metadata",
"and",
"start",
"the",
"policy",
"resolution",
"at",
"the",
"create",
"event",
".",
"No",
"need",
"to",
"wait",
"for",
"the",
"start",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L429-L459 |
7,018 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | handleStartEvent | func (d *DockerMonitor) handleStartEvent(ctx context.Context, event *events.Message) error {
container, err := d.retrieveDockerInfo(ctx, event)
if err != nil {
return err
}
if !container.State.Running {
return nil
}
puID, err := puIDFromDockerID(container.ID)
if err != nil {
return err
}
runtime, err := d.extractMetadata(container)
if err != nil {
return err
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
if err = d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventStart, runtime); err != nil {
if d.killContainerOnPolicyError {
timeout := 0 * time.Second
if err1 := d.dockerClient.ContainerStop(ctx, event.ID, &timeout); err1 != nil {
zap.L().Warn("Unable to stop illegal container",
zap.String("dockerID", event.ID),
zap.Error(err1),
)
}
d.config.Collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: event.ID,
IPAddress: nil,
Tags: nil,
Event: collector.ContainerFailed,
})
return fmt.Errorf("unable to start container because of policy: container %s killed: %s", event.ID, err)
}
return fmt.Errorf("unable to set policy: container %s kept alive per policy: %s", puID, err)
}
// if the container has hostnet set to true or is linked
// to container with hostnet set to true, program the cgroup.
if isHostNetworkContainer(runtime) {
if err = d.setupHostMode(puID, runtime, container); err != nil {
return fmt.Errorf("unable to setup host mode for container %s: %s", puID, err)
}
}
return nil
} | go | func (d *DockerMonitor) handleStartEvent(ctx context.Context, event *events.Message) error {
container, err := d.retrieveDockerInfo(ctx, event)
if err != nil {
return err
}
if !container.State.Running {
return nil
}
puID, err := puIDFromDockerID(container.ID)
if err != nil {
return err
}
runtime, err := d.extractMetadata(container)
if err != nil {
return err
}
// If it is a host container, we need to activate it as a Linux process. We will
// override the options that the metadata extractor provided.
if container.HostConfig.NetworkMode == constants.DockerHostMode {
options := hostModeOptions(container)
options.PolicyExtensions = runtime.Options().PolicyExtensions
runtime.SetOptions(*options)
runtime.SetPUType(common.LinuxProcessPU)
}
runtime.SetOptions(runtime.Options())
if err = d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventStart, runtime); err != nil {
if d.killContainerOnPolicyError {
timeout := 0 * time.Second
if err1 := d.dockerClient.ContainerStop(ctx, event.ID, &timeout); err1 != nil {
zap.L().Warn("Unable to stop illegal container",
zap.String("dockerID", event.ID),
zap.Error(err1),
)
}
d.config.Collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: event.ID,
IPAddress: nil,
Tags: nil,
Event: collector.ContainerFailed,
})
return fmt.Errorf("unable to start container because of policy: container %s killed: %s", event.ID, err)
}
return fmt.Errorf("unable to set policy: container %s kept alive per policy: %s", puID, err)
}
// if the container has hostnet set to true or is linked
// to container with hostnet set to true, program the cgroup.
if isHostNetworkContainer(runtime) {
if err = d.setupHostMode(puID, runtime, container); err != nil {
return fmt.Errorf("unable to setup host mode for container %s: %s", puID, err)
}
}
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"handleStartEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
"{",
"container",
",",
"err",
":=",
"d",
".",
"retrieveDockerInfo",
"(",
"ctx",
",",
"event",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"container",
".",
"State",
".",
"Running",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"puID",
",",
"err",
":=",
"puIDFromDockerID",
"(",
"container",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"runtime",
",",
"err",
":=",
"d",
".",
"extractMetadata",
"(",
"container",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// If it is a host container, we need to activate it as a Linux process. We will",
"// override the options that the metadata extractor provided.",
"if",
"container",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
"{",
"options",
":=",
"hostModeOptions",
"(",
"container",
")",
"\n",
"options",
".",
"PolicyExtensions",
"=",
"runtime",
".",
"Options",
"(",
")",
".",
"PolicyExtensions",
"\n",
"runtime",
".",
"SetOptions",
"(",
"*",
"options",
")",
"\n",
"runtime",
".",
"SetPUType",
"(",
"common",
".",
"LinuxProcessPU",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"if",
"err",
"=",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"tevents",
".",
"EventStart",
",",
"runtime",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"d",
".",
"killContainerOnPolicyError",
"{",
"timeout",
":=",
"0",
"*",
"time",
".",
"Second",
"\n",
"if",
"err1",
":=",
"d",
".",
"dockerClient",
".",
"ContainerStop",
"(",
"ctx",
",",
"event",
".",
"ID",
",",
"&",
"timeout",
")",
";",
"err1",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"event",
".",
"ID",
")",
",",
"zap",
".",
"Error",
"(",
"err1",
")",
",",
")",
"\n",
"}",
"\n",
"d",
".",
"config",
".",
"Collector",
".",
"CollectContainerEvent",
"(",
"&",
"collector",
".",
"ContainerRecord",
"{",
"ContextID",
":",
"event",
".",
"ID",
",",
"IPAddress",
":",
"nil",
",",
"Tags",
":",
"nil",
",",
"Event",
":",
"collector",
".",
"ContainerFailed",
",",
"}",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
".",
"ID",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"puID",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// if the container has hostnet set to true or is linked",
"// to container with hostnet set to true, program the cgroup.",
"if",
"isHostNetworkContainer",
"(",
"runtime",
")",
"{",
"if",
"err",
"=",
"d",
".",
"setupHostMode",
"(",
"puID",
",",
"runtime",
",",
"container",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"puID",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // handleStartEvent will notify the policy engine immediately about the event in order
// to start the implementation of the functions. At this point we know the process ID
// that is needed for the remote enforcers. | [
"handleStartEvent",
"will",
"notify",
"the",
"policy",
"engine",
"immediately",
"about",
"the",
"event",
"in",
"order",
"to",
"start",
"the",
"implementation",
"of",
"the",
"functions",
".",
"At",
"this",
"point",
"we",
"know",
"the",
"process",
"ID",
"that",
"is",
"needed",
"for",
"the",
"remote",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L464-L524 |
7,019 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | handleDestroyEvent | func (d *DockerMonitor) handleDestroyEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
err = d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventDestroy, runtime)
if err != nil {
zap.L().Error("Failed to handle delete event",
zap.Error(err),
)
}
if err := d.netcls.DeleteCgroup(puID); err != nil {
zap.L().Warn("Failed to clean netcls group",
zap.String("puID", puID),
zap.Error(err),
)
}
return nil
} | go | func (d *DockerMonitor) handleDestroyEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
err = d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventDestroy, runtime)
if err != nil {
zap.L().Error("Failed to handle delete event",
zap.Error(err),
)
}
if err := d.netcls.DeleteCgroup(puID); err != nil {
zap.L().Warn("Failed to clean netcls group",
zap.String("puID", puID),
zap.Error(err),
)
}
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"handleDestroyEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
"{",
"puID",
",",
"err",
":=",
"puIDFromDockerID",
"(",
"event",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"runtime",
":=",
"policy",
".",
"NewPURuntimeWithDefaults",
"(",
")",
"\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"err",
"=",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"tevents",
".",
"EventDestroy",
",",
"runtime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"netcls",
".",
"DeleteCgroup",
"(",
"puID",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"puID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handleDestroyEvent handles destroy events from Docker. It generated a "Destroy event" | [
"handleDestroyEvent",
"handles",
"destroy",
"events",
"from",
"Docker",
".",
"It",
"generated",
"a",
"Destroy",
"event"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L541-L565 |
7,020 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | handlePauseEvent | func (d *DockerMonitor) handlePauseEvent(ctx context.Context, event *events.Message) error {
zap.L().Info("UnPause Event for nativeID", zap.String("ID", event.ID))
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventPause, runtime)
} | go | func (d *DockerMonitor) handlePauseEvent(ctx context.Context, event *events.Message) error {
zap.L().Info("UnPause Event for nativeID", zap.String("ID", event.ID))
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventPause, runtime)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"handlePauseEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Info",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"event",
".",
"ID",
")",
")",
"\n\n",
"puID",
",",
"err",
":=",
"puIDFromDockerID",
"(",
"event",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"runtime",
":=",
"policy",
".",
"NewPURuntimeWithDefaults",
"(",
")",
"\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"return",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"tevents",
".",
"EventPause",
",",
"runtime",
")",
"\n",
"}"
] | // handlePauseEvent generates a create event type. | [
"handlePauseEvent",
"generates",
"a",
"create",
"event",
"type",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L568-L580 |
7,021 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | handleUnpauseEvent | func (d *DockerMonitor) handleUnpauseEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventUnpause, runtime)
} | go | func (d *DockerMonitor) handleUnpauseEvent(ctx context.Context, event *events.Message) error {
puID, err := puIDFromDockerID(event.ID)
if err != nil {
return err
}
runtime := policy.NewPURuntimeWithDefaults()
runtime.SetOptions(runtime.Options())
return d.config.Policy.HandlePUEvent(ctx, puID, tevents.EventUnpause, runtime)
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"handleUnpauseEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"*",
"events",
".",
"Message",
")",
"error",
"{",
"puID",
",",
"err",
":=",
"puIDFromDockerID",
"(",
"event",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"runtime",
":=",
"policy",
".",
"NewPURuntimeWithDefaults",
"(",
")",
"\n",
"runtime",
".",
"SetOptions",
"(",
"runtime",
".",
"Options",
"(",
")",
")",
"\n\n",
"return",
"d",
".",
"config",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"tevents",
".",
"EventUnpause",
",",
"runtime",
")",
"\n",
"}"
] | // handleCreateEvent generates a create event type. | [
"handleCreateEvent",
"generates",
"a",
"create",
"event",
"type",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L583-L594 |
7,022 | aporeto-inc/trireme-lib | monitor/internal/docker/monitor.go | waitForDockerDaemon | func (d *DockerMonitor) waitForDockerDaemon(ctx context.Context) (err error) {
done := make(chan bool)
go func() {
for errg := d.setupDockerDaemon(); errg != nil; {
zap.L().Debug("Unable to init docker client. Retrying...", zap.Error(errg))
<-time.After(dockerRetryTimer)
continue
}
done <- true
}()
select {
case <-ctx.Done():
return nil
case <-time.After(dockerInitializationWait):
return fmt.Errorf("Unable to connect to docker daemon")
case <-done:
}
return nil
} | go | func (d *DockerMonitor) waitForDockerDaemon(ctx context.Context) (err error) {
done := make(chan bool)
go func() {
for errg := d.setupDockerDaemon(); errg != nil; {
zap.L().Debug("Unable to init docker client. Retrying...", zap.Error(errg))
<-time.After(dockerRetryTimer)
continue
}
done <- true
}()
select {
case <-ctx.Done():
return nil
case <-time.After(dockerInitializationWait):
return fmt.Errorf("Unable to connect to docker daemon")
case <-done:
}
return nil
} | [
"func",
"(",
"d",
"*",
"DockerMonitor",
")",
"waitForDockerDaemon",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"done",
":=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"errg",
":=",
"d",
".",
"setupDockerDaemon",
"(",
")",
";",
"errg",
"!=",
"nil",
";",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"errg",
")",
")",
"\n",
"<-",
"time",
".",
"After",
"(",
"dockerRetryTimer",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"done",
"<-",
"true",
"\n",
"}",
"(",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"dockerInitializationWait",
")",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"<-",
"done",
":",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // waitForDockerDaemon is a blocking call which will try to bring up docker, if not return err
// with timeout | [
"waitForDockerDaemon",
"is",
"a",
"blocking",
"call",
"which",
"will",
"try",
"to",
"bring",
"up",
"docker",
"if",
"not",
"return",
"err",
"with",
"timeout"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/monitor.go#L654-L675 |
7,023 | aporeto-inc/trireme-lib | controller/pkg/secrets/secrets.go | NewSecrets | func NewSecrets(s PublicSecrets) (Secrets, error) {
switch s.SecretsType() {
case PKICompactType:
t := s.(*CompactPKIPublicSecrets)
return NewCompactPKIWithTokenCA(t.Key, t.Certificate, t.CA, t.TokenCAs, t.Token, t.Compressed)
default:
return nil, fmt.Errorf("Unsupported type")
}
} | go | func NewSecrets(s PublicSecrets) (Secrets, error) {
switch s.SecretsType() {
case PKICompactType:
t := s.(*CompactPKIPublicSecrets)
return NewCompactPKIWithTokenCA(t.Key, t.Certificate, t.CA, t.TokenCAs, t.Token, t.Compressed)
default:
return nil, fmt.Errorf("Unsupported type")
}
} | [
"func",
"NewSecrets",
"(",
"s",
"PublicSecrets",
")",
"(",
"Secrets",
",",
"error",
")",
"{",
"switch",
"s",
".",
"SecretsType",
"(",
")",
"{",
"case",
"PKICompactType",
":",
"t",
":=",
"s",
".",
"(",
"*",
"CompactPKIPublicSecrets",
")",
"\n",
"return",
"NewCompactPKIWithTokenCA",
"(",
"t",
".",
"Key",
",",
"t",
".",
"Certificate",
",",
"t",
".",
"CA",
",",
"t",
".",
"TokenCAs",
",",
"t",
".",
"Token",
",",
"t",
".",
"Compressed",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // NewSecrets creates a new set of secrets based on the type. | [
"NewSecrets",
"creates",
"a",
"new",
"set",
"of",
"secrets",
"based",
"on",
"the",
"type",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/secrets/secrets.go#L42-L50 |
7,024 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | NewTable | func NewTable() *ServiceCache {
return &ServiceCache{
local: map[int]map[uint32]entryList{},
remote: map[int]map[uint32]entryList{},
remoteHosts: map[string]entryList{},
localHosts: map[string]entryList{},
}
} | go | func NewTable() *ServiceCache {
return &ServiceCache{
local: map[int]map[uint32]entryList{},
remote: map[int]map[uint32]entryList{},
remoteHosts: map[string]entryList{},
localHosts: map[string]entryList{},
}
} | [
"func",
"NewTable",
"(",
")",
"*",
"ServiceCache",
"{",
"return",
"&",
"ServiceCache",
"{",
"local",
":",
"map",
"[",
"int",
"]",
"map",
"[",
"uint32",
"]",
"entryList",
"{",
"}",
",",
"remote",
":",
"map",
"[",
"int",
"]",
"map",
"[",
"uint32",
"]",
"entryList",
"{",
"}",
",",
"remoteHosts",
":",
"map",
"[",
"string",
"]",
"entryList",
"{",
"}",
",",
"localHosts",
":",
"map",
"[",
"string",
"]",
"entryList",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewTable creates a new table | [
"NewTable",
"creates",
"a",
"new",
"table"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L43-L50 |
7,025 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | Add | func (s *ServiceCache) Add(e *common.Service, id string, data interface{}, local bool) error {
s.Lock()
defer s.Unlock()
record := &entry{
ports: e.Ports,
data: data,
id: id,
}
if err := s.addPorts(e, record, local); err != nil {
return err
}
if err := s.addHostService(e, record, local); err != nil {
return err
}
return s.addIPService(e, record, local)
} | go | func (s *ServiceCache) Add(e *common.Service, id string, data interface{}, local bool) error {
s.Lock()
defer s.Unlock()
record := &entry{
ports: e.Ports,
data: data,
id: id,
}
if err := s.addPorts(e, record, local); err != nil {
return err
}
if err := s.addHostService(e, record, local); err != nil {
return err
}
return s.addIPService(e, record, local)
} | [
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"Add",
"(",
"e",
"*",
"common",
".",
"Service",
",",
"id",
"string",
",",
"data",
"interface",
"{",
"}",
",",
"local",
"bool",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"record",
":=",
"&",
"entry",
"{",
"ports",
":",
"e",
".",
"Ports",
",",
"data",
":",
"data",
",",
"id",
":",
"id",
",",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"addPorts",
"(",
"e",
",",
"record",
",",
"local",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"s",
".",
"addHostService",
"(",
"e",
",",
"record",
",",
"local",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"addIPService",
"(",
"e",
",",
"record",
",",
"local",
")",
"\n",
"}"
] | // Add adds a service into the cache. Returns error of if any overlap has been detected. | [
"Add",
"adds",
"a",
"service",
"into",
"the",
"cache",
".",
"Returns",
"error",
"of",
"if",
"any",
"overlap",
"has",
"been",
"detected",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L53-L71 |
7,026 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | Find | func (s *ServiceCache) Find(ip net.IP, port int, host string, local bool) interface{} {
s.RLock()
defer s.RUnlock()
if host != "" {
if data := s.findHost(host, port, local); data != nil {
return data
}
}
return s.findIP(ip, port, local)
} | go | func (s *ServiceCache) Find(ip net.IP, port int, host string, local bool) interface{} {
s.RLock()
defer s.RUnlock()
if host != "" {
if data := s.findHost(host, port, local); data != nil {
return data
}
}
return s.findIP(ip, port, local)
} | [
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"Find",
"(",
"ip",
"net",
".",
"IP",
",",
"port",
"int",
",",
"host",
"string",
",",
"local",
"bool",
")",
"interface",
"{",
"}",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"host",
"!=",
"\"",
"\"",
"{",
"if",
"data",
":=",
"s",
".",
"findHost",
"(",
"host",
",",
"port",
",",
"local",
")",
";",
"data",
"!=",
"nil",
"{",
"return",
"data",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"findIP",
"(",
"ip",
",",
"port",
",",
"local",
")",
"\n",
"}"
] | // Find searches for a matching service, given an IP and port. Caller must specify
// the local or remote context. | [
"Find",
"searches",
"for",
"a",
"matching",
"service",
"given",
"an",
"IP",
"and",
"port",
".",
"Caller",
"must",
"specify",
"the",
"local",
"or",
"remote",
"context",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L75-L86 |
7,027 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | FindListeningServicesForPU | func (s *ServiceCache) FindListeningServicesForPU(id string) (interface{}, *portspec.PortSpec) {
s.RLock()
defer s.RUnlock()
for _, spec := range s.localPorts {
if spec.id == id {
return spec.data, spec.ports
}
}
return nil, nil
} | go | func (s *ServiceCache) FindListeningServicesForPU(id string) (interface{}, *portspec.PortSpec) {
s.RLock()
defer s.RUnlock()
for _, spec := range s.localPorts {
if spec.id == id {
return spec.data, spec.ports
}
}
return nil, nil
} | [
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"FindListeningServicesForPU",
"(",
"id",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"*",
"portspec",
".",
"PortSpec",
")",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"spec",
":=",
"range",
"s",
".",
"localPorts",
"{",
"if",
"spec",
".",
"id",
"==",
"id",
"{",
"return",
"spec",
".",
"data",
",",
"spec",
".",
"ports",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // FindListeningServicesForPU returns a service that is found and the associated
// portSpecifications that refer to this service. | [
"FindListeningServicesForPU",
"returns",
"a",
"service",
"that",
"is",
"found",
"and",
"the",
"associated",
"portSpecifications",
"that",
"refer",
"to",
"this",
"service",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L90-L100 |
7,028 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | DeleteByID | func (s *ServiceCache) DeleteByID(id string, local bool) {
s.Lock()
defer s.Unlock()
hosts := s.remoteHosts
prefixes := s.remote
if local {
hosts = s.localHosts
prefixes = s.local
}
if local {
s.localPorts = deleteMatchingPorts(s.localPorts, id)
} else {
s.remotePorts = deleteMatchingPorts(s.remotePorts, id)
}
for host, ports := range hosts {
hosts[host] = deleteMatchingPorts(ports, id)
if len(hosts[host]) == 0 {
delete(hosts, host)
}
}
for l, prefix := range prefixes {
for ip, ports := range prefix {
prefix[ip] = deleteMatchingPorts(ports, id)
if len(prefix[ip]) == 0 {
delete(prefix, ip)
}
}
if len(prefix) == 0 {
delete(prefixes, l)
}
}
} | go | func (s *ServiceCache) DeleteByID(id string, local bool) {
s.Lock()
defer s.Unlock()
hosts := s.remoteHosts
prefixes := s.remote
if local {
hosts = s.localHosts
prefixes = s.local
}
if local {
s.localPorts = deleteMatchingPorts(s.localPorts, id)
} else {
s.remotePorts = deleteMatchingPorts(s.remotePorts, id)
}
for host, ports := range hosts {
hosts[host] = deleteMatchingPorts(ports, id)
if len(hosts[host]) == 0 {
delete(hosts, host)
}
}
for l, prefix := range prefixes {
for ip, ports := range prefix {
prefix[ip] = deleteMatchingPorts(ports, id)
if len(prefix[ip]) == 0 {
delete(prefix, ip)
}
}
if len(prefix) == 0 {
delete(prefixes, l)
}
}
} | [
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"DeleteByID",
"(",
"id",
"string",
",",
"local",
"bool",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"hosts",
":=",
"s",
".",
"remoteHosts",
"\n",
"prefixes",
":=",
"s",
".",
"remote",
"\n",
"if",
"local",
"{",
"hosts",
"=",
"s",
".",
"localHosts",
"\n",
"prefixes",
"=",
"s",
".",
"local",
"\n",
"}",
"\n\n",
"if",
"local",
"{",
"s",
".",
"localPorts",
"=",
"deleteMatchingPorts",
"(",
"s",
".",
"localPorts",
",",
"id",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"remotePorts",
"=",
"deleteMatchingPorts",
"(",
"s",
".",
"remotePorts",
",",
"id",
")",
"\n",
"}",
"\n\n",
"for",
"host",
",",
"ports",
":=",
"range",
"hosts",
"{",
"hosts",
"[",
"host",
"]",
"=",
"deleteMatchingPorts",
"(",
"ports",
",",
"id",
")",
"\n",
"if",
"len",
"(",
"hosts",
"[",
"host",
"]",
")",
"==",
"0",
"{",
"delete",
"(",
"hosts",
",",
"host",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"l",
",",
"prefix",
":=",
"range",
"prefixes",
"{",
"for",
"ip",
",",
"ports",
":=",
"range",
"prefix",
"{",
"prefix",
"[",
"ip",
"]",
"=",
"deleteMatchingPorts",
"(",
"ports",
",",
"id",
")",
"\n",
"if",
"len",
"(",
"prefix",
"[",
"ip",
"]",
")",
"==",
"0",
"{",
"delete",
"(",
"prefix",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"prefix",
")",
"==",
"0",
"{",
"delete",
"(",
"prefixes",
",",
"l",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // DeleteByID will delete all entries related to this ID from all references. | [
"DeleteByID",
"will",
"delete",
"all",
"entries",
"related",
"to",
"this",
"ID",
"from",
"all",
"references",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L103-L138 |
7,029 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/servicecache/servicecache.go | addPorts | func (s *ServiceCache) addPorts(e *common.Service, record *entry, local bool) error {
if !local {
return nil
}
for _, spec := range s.localPorts {
if spec.ports.Overlaps(e.Ports) {
return fmt.Errorf("service port overlap in the global port list: %+v %s", e.Addresses, e.Ports.String())
}
}
s.localPorts = append(s.localPorts, record)
return nil
} | go | func (s *ServiceCache) addPorts(e *common.Service, record *entry, local bool) error {
if !local {
return nil
}
for _, spec := range s.localPorts {
if spec.ports.Overlaps(e.Ports) {
return fmt.Errorf("service port overlap in the global port list: %+v %s", e.Addresses, e.Ports.String())
}
}
s.localPorts = append(s.localPorts, record)
return nil
} | [
"func",
"(",
"s",
"*",
"ServiceCache",
")",
"addPorts",
"(",
"e",
"*",
"common",
".",
"Service",
",",
"record",
"*",
"entry",
",",
"local",
"bool",
")",
"error",
"{",
"if",
"!",
"local",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"spec",
":=",
"range",
"s",
".",
"localPorts",
"{",
"if",
"spec",
".",
"ports",
".",
"Overlaps",
"(",
"e",
".",
"Ports",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e",
".",
"Addresses",
",",
"e",
".",
"Ports",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"localPorts",
"=",
"append",
"(",
"s",
".",
"localPorts",
",",
"record",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // addPorts will only work for local ports. | [
"addPorts",
"will",
"only",
"work",
"for",
"local",
"ports",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/servicecache/servicecache.go#L257-L271 |
7,030 | aporeto-inc/trireme-lib | controller/internal/supervisor/proxy/supervisorproxy.go | Supervise | func (s *ProxyInfo) Supervise(contextID string, puInfo *policy.PUInfo) error {
return nil
} | go | func (s *ProxyInfo) Supervise(contextID string, puInfo *policy.PUInfo) error {
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"Supervise",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] | // Supervise just keeps track of the active remotes so that it can initiate updates. | [
"Supervise",
"just",
"keeps",
"track",
"of",
"the",
"active",
"remotes",
"so",
"that",
"it",
"can",
"initiate",
"updates",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/proxy/supervisorproxy.go#L17-L20 |
7,031 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | NewMockMonitor | func NewMockMonitor(ctrl *gomock.Controller) *MockMonitor {
mock := &MockMonitor{ctrl: ctrl}
mock.recorder = &MockMonitorMockRecorder{mock}
return mock
} | go | func NewMockMonitor(ctrl *gomock.Controller) *MockMonitor {
mock := &MockMonitor{ctrl: ctrl}
mock.recorder = &MockMonitorMockRecorder{mock}
return mock
} | [
"func",
"NewMockMonitor",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockMonitor",
"{",
"mock",
":=",
"&",
"MockMonitor",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockMonitorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockMonitor creates a new mock instance
// nolint | [
"NewMockMonitor",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L31-L35 |
7,032 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | NewMockImplementation | func NewMockImplementation(ctrl *gomock.Controller) *MockImplementation {
mock := &MockImplementation{ctrl: ctrl}
mock.recorder = &MockImplementationMockRecorder{mock}
return mock
} | go | func NewMockImplementation(ctrl *gomock.Controller) *MockImplementation {
mock := &MockImplementation{ctrl: ctrl}
mock.recorder = &MockImplementationMockRecorder{mock}
return mock
} | [
"func",
"NewMockImplementation",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockImplementation",
"{",
"mock",
":=",
"&",
"MockImplementation",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockImplementationMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockImplementation creates a new mock instance
// nolint | [
"NewMockImplementation",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L100-L104 |
7,033 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | SetupConfig | func (m *MockImplementation) SetupConfig(registerer registerer.Registerer, cfg interface{}) error {
ret := m.ctrl.Call(m, "SetupConfig", registerer, cfg)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockImplementation) SetupConfig(registerer registerer.Registerer, cfg interface{}) error {
ret := m.ctrl.Call(m, "SetupConfig", registerer, cfg)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockImplementation",
")",
"SetupConfig",
"(",
"registerer",
"registerer",
".",
"Registerer",
",",
"cfg",
"interface",
"{",
"}",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"registerer",
",",
"cfg",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // SetupConfig mocks base method
// nolint | [
"SetupConfig",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L128-L132 |
7,034 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | SetupConfig | func (mr *MockImplementationMockRecorder) SetupConfig(registerer, cfg interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupConfig", reflect.TypeOf((*MockImplementation)(nil).SetupConfig), registerer, cfg)
} | go | func (mr *MockImplementationMockRecorder) SetupConfig(registerer, cfg interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupConfig", reflect.TypeOf((*MockImplementation)(nil).SetupConfig), registerer, cfg)
} | [
"func",
"(",
"mr",
"*",
"MockImplementationMockRecorder",
")",
"SetupConfig",
"(",
"registerer",
",",
"cfg",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockImplementation",
")",
"(",
"nil",
")",
".",
"SetupConfig",
")",
",",
"registerer",
",",
"cfg",
")",
"\n",
"}"
] | // SetupConfig indicates an expected call of SetupConfig
// nolint | [
"SetupConfig",
"indicates",
"an",
"expected",
"call",
"of",
"SetupConfig",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L136-L138 |
7,035 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | SetupHandlers | func (m *MockImplementation) SetupHandlers(c *config.ProcessorConfig) {
m.ctrl.Call(m, "SetupHandlers", c)
} | go | func (m *MockImplementation) SetupHandlers(c *config.ProcessorConfig) {
m.ctrl.Call(m, "SetupHandlers", c)
} | [
"func",
"(",
"m",
"*",
"MockImplementation",
")",
"SetupHandlers",
"(",
"c",
"*",
"config",
".",
"ProcessorConfig",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"c",
")",
"\n",
"}"
] | // SetupHandlers mocks base method
// nolint | [
"SetupHandlers",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L142-L144 |
7,036 | aporeto-inc/trireme-lib | monitor/mockmonitor/mockmonitor.go | SetupHandlers | func (mr *MockImplementationMockRecorder) SetupHandlers(c interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHandlers", reflect.TypeOf((*MockImplementation)(nil).SetupHandlers), c)
} | go | func (mr *MockImplementationMockRecorder) SetupHandlers(c interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHandlers", reflect.TypeOf((*MockImplementation)(nil).SetupHandlers), c)
} | [
"func",
"(",
"mr",
"*",
"MockImplementationMockRecorder",
")",
"SetupHandlers",
"(",
"c",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockImplementation",
")",
"(",
"nil",
")",
".",
"SetupHandlers",
")",
",",
"c",
")",
"\n",
"}"
] | // SetupHandlers indicates an expected call of SetupHandlers
// nolint | [
"SetupHandlers",
"indicates",
"an",
"expected",
"call",
"of",
"SetupHandlers",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/mockmonitor/mockmonitor.go#L148-L150 |
7,037 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/ipsetprovider.go | NewIpset | func (i *goIpsetProvider) NewIpset(name string, hasht string, p *ipset.Params) (Ipset, error) {
return ipset.New(name, hasht, p)
} | go | func (i *goIpsetProvider) NewIpset(name string, hasht string, p *ipset.Params) (Ipset, error) {
return ipset.New(name, hasht, p)
} | [
"func",
"(",
"i",
"*",
"goIpsetProvider",
")",
"NewIpset",
"(",
"name",
"string",
",",
"hasht",
"string",
",",
"p",
"*",
"ipset",
".",
"Params",
")",
"(",
"Ipset",
",",
"error",
")",
"{",
"return",
"ipset",
".",
"New",
"(",
"name",
",",
"hasht",
",",
"p",
")",
"\n",
"}"
] | // NewIpset returns an IpsetProvider interface based on the go-ipset
// external package. | [
"NewIpset",
"returns",
"an",
"IpsetProvider",
"interface",
"based",
"on",
"the",
"go",
"-",
"ipset",
"external",
"package",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/ipsetprovider.go#L34-L36 |
7,038 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/ipsetprovider.go | GetIpset | func (i *goIpsetProvider) GetIpset(name string) Ipset {
return &ipset.IPSet{
Name: name,
}
} | go | func (i *goIpsetProvider) GetIpset(name string) Ipset {
return &ipset.IPSet{
Name: name,
}
} | [
"func",
"(",
"i",
"*",
"goIpsetProvider",
")",
"GetIpset",
"(",
"name",
"string",
")",
"Ipset",
"{",
"return",
"&",
"ipset",
".",
"IPSet",
"{",
"Name",
":",
"name",
",",
"}",
"\n",
"}"
] | // GetIpset gets the ipset object from the name. | [
"GetIpset",
"gets",
"the",
"ipset",
"object",
"from",
"the",
"name",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/ipsetprovider.go#L39-L43 |
7,039 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/ipsetprovider.go | DestroyAll | func (i *goIpsetProvider) DestroyAll(prefix string) error {
sets, err := i.ListIPSets()
if err != nil {
return ipset.DestroyAll()
}
for _, s := range sets {
if !strings.HasPrefix(s, prefix) {
continue
}
ips := i.GetIpset(s)
if err := ips.Destroy(); err != nil {
return ipset.DestroyAll()
}
}
return nil
} | go | func (i *goIpsetProvider) DestroyAll(prefix string) error {
sets, err := i.ListIPSets()
if err != nil {
return ipset.DestroyAll()
}
for _, s := range sets {
if !strings.HasPrefix(s, prefix) {
continue
}
ips := i.GetIpset(s)
if err := ips.Destroy(); err != nil {
return ipset.DestroyAll()
}
}
return nil
} | [
"func",
"(",
"i",
"*",
"goIpsetProvider",
")",
"DestroyAll",
"(",
"prefix",
"string",
")",
"error",
"{",
"sets",
",",
"err",
":=",
"i",
".",
"ListIPSets",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ipset",
".",
"DestroyAll",
"(",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"sets",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"s",
",",
"prefix",
")",
"{",
"continue",
"\n",
"}",
"\n",
"ips",
":=",
"i",
".",
"GetIpset",
"(",
"s",
")",
"\n",
"if",
"err",
":=",
"ips",
".",
"Destroy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ipset",
".",
"DestroyAll",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // DestroyAll destroys all the ipsets - it will fail if there are existing references | [
"DestroyAll",
"destroys",
"all",
"the",
"ipsets",
"-",
"it",
"will",
"fail",
"if",
"there",
"are",
"existing",
"references"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/ipsetprovider.go#L46-L64 |
7,040 | aporeto-inc/trireme-lib | monitor/monitor.go | UpdateConfiguration | func (m *monitors) UpdateConfiguration(ctx context.Context, config *config.MonitorConfig) error {
// Monitor configuration cannot change at this time.
// TODO:
return nil
} | go | func (m *monitors) UpdateConfiguration(ctx context.Context, config *config.MonitorConfig) error {
// Monitor configuration cannot change at this time.
// TODO:
return nil
} | [
"func",
"(",
"m",
"*",
"monitors",
")",
"UpdateConfiguration",
"(",
"ctx",
"context",
".",
"Context",
",",
"config",
"*",
"config",
".",
"MonitorConfig",
")",
"error",
"{",
"// Monitor configuration cannot change at this time.",
"// TODO:",
"return",
"nil",
"\n",
"}"
] | // UpdateConfiguration updates the configuration of the monitors. | [
"UpdateConfiguration",
"updates",
"the",
"configuration",
"of",
"the",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/monitor.go#L150-L154 |
7,041 | aporeto-inc/trireme-lib | monitor/monitor.go | Resync | func (m *monitors) Resync(ctx context.Context) error {
failure := false
var errs string
for _, i := range m.monitors {
if err := i.Resync(ctx); err != nil {
errs = errs + err.Error()
failure = true
}
}
if failure {
return fmt.Errorf("Monitor resync failed: %s", errs)
}
return nil
} | go | func (m *monitors) Resync(ctx context.Context) error {
failure := false
var errs string
for _, i := range m.monitors {
if err := i.Resync(ctx); err != nil {
errs = errs + err.Error()
failure = true
}
}
if failure {
return fmt.Errorf("Monitor resync failed: %s", errs)
}
return nil
} | [
"func",
"(",
"m",
"*",
"monitors",
")",
"Resync",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"failure",
":=",
"false",
"\n",
"var",
"errs",
"string",
"\n\n",
"for",
"_",
",",
"i",
":=",
"range",
"m",
".",
"monitors",
"{",
"if",
"err",
":=",
"i",
".",
"Resync",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"errs",
"+",
"err",
".",
"Error",
"(",
")",
"\n",
"failure",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"failure",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errs",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Resync resyncs the monitor | [
"Resync",
"resyncs",
"the",
"monitor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/monitor.go#L157-L174 |
7,042 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath.go | Enforce | func (d *Datapath) Enforce(contextID string, puInfo *policy.PUInfo) error {
// Always create a new PU context
pu, err := pucontext.NewPU(contextID, puInfo, d.ExternalIPCacheTimeout)
if err != nil {
return fmt.Errorf("error creating new pu: %s", err)
}
// Cache PUs for retrieval based on packet information
if pu.Type() != common.ContainerPU {
mark, tcpPorts, udpPorts := pu.GetProcessKeys()
d.puFromMark.AddOrUpdate(mark, pu)
if pu.Type() == common.UIDLoginPU {
user := puInfo.Runtime.Options().UserID
d.puFromUser.AddOrUpdate(user, pu)
}
for _, port := range tcpPorts {
if port == "0" {
continue
}
portSpec, err := portspec.NewPortSpecFromString(port, contextID)
if err != nil {
continue
}
if puInfo.Runtime.PUType() == common.HostPU {
d.contextIDFromTCPPort.AddPortSpecToEnd(portSpec)
} else {
d.contextIDFromTCPPort.AddPortSpec(portSpec)
}
}
for _, port := range udpPorts {
portSpec, err := portspec.NewPortSpecFromString(port, contextID)
if err != nil {
continue
}
// check for host pu and add its ports to the end.
if puInfo.Runtime.PUType() == common.HostPU {
d.contextIDFromUDPPort.AddPortSpecToEnd(portSpec)
} else {
d.contextIDFromUDPPort.AddPortSpec(portSpec)
}
}
} else {
d.puFromIP = pu
}
// pucontext launches a go routine to periodically
// lookup dns names. ctx cancel signals the go routine to exit
if prevPU, _ := d.puFromContextID.Get(contextID); prevPU != nil {
prevPU.(*pucontext.PUContext).CancelFunc()
}
// Cache PU from contextID for management and policy updates
d.puFromContextID.AddOrUpdate(contextID, pu)
return nil
} | go | func (d *Datapath) Enforce(contextID string, puInfo *policy.PUInfo) error {
// Always create a new PU context
pu, err := pucontext.NewPU(contextID, puInfo, d.ExternalIPCacheTimeout)
if err != nil {
return fmt.Errorf("error creating new pu: %s", err)
}
// Cache PUs for retrieval based on packet information
if pu.Type() != common.ContainerPU {
mark, tcpPorts, udpPorts := pu.GetProcessKeys()
d.puFromMark.AddOrUpdate(mark, pu)
if pu.Type() == common.UIDLoginPU {
user := puInfo.Runtime.Options().UserID
d.puFromUser.AddOrUpdate(user, pu)
}
for _, port := range tcpPorts {
if port == "0" {
continue
}
portSpec, err := portspec.NewPortSpecFromString(port, contextID)
if err != nil {
continue
}
if puInfo.Runtime.PUType() == common.HostPU {
d.contextIDFromTCPPort.AddPortSpecToEnd(portSpec)
} else {
d.contextIDFromTCPPort.AddPortSpec(portSpec)
}
}
for _, port := range udpPorts {
portSpec, err := portspec.NewPortSpecFromString(port, contextID)
if err != nil {
continue
}
// check for host pu and add its ports to the end.
if puInfo.Runtime.PUType() == common.HostPU {
d.contextIDFromUDPPort.AddPortSpecToEnd(portSpec)
} else {
d.contextIDFromUDPPort.AddPortSpec(portSpec)
}
}
} else {
d.puFromIP = pu
}
// pucontext launches a go routine to periodically
// lookup dns names. ctx cancel signals the go routine to exit
if prevPU, _ := d.puFromContextID.Get(contextID); prevPU != nil {
prevPU.(*pucontext.PUContext).CancelFunc()
}
// Cache PU from contextID for management and policy updates
d.puFromContextID.AddOrUpdate(contextID, pu)
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"Enforce",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"// Always create a new PU context",
"pu",
",",
"err",
":=",
"pucontext",
".",
"NewPU",
"(",
"contextID",
",",
"puInfo",
",",
"d",
".",
"ExternalIPCacheTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Cache PUs for retrieval based on packet information",
"if",
"pu",
".",
"Type",
"(",
")",
"!=",
"common",
".",
"ContainerPU",
"{",
"mark",
",",
"tcpPorts",
",",
"udpPorts",
":=",
"pu",
".",
"GetProcessKeys",
"(",
")",
"\n",
"d",
".",
"puFromMark",
".",
"AddOrUpdate",
"(",
"mark",
",",
"pu",
")",
"\n\n",
"if",
"pu",
".",
"Type",
"(",
")",
"==",
"common",
".",
"UIDLoginPU",
"{",
"user",
":=",
"puInfo",
".",
"Runtime",
".",
"Options",
"(",
")",
".",
"UserID",
"\n",
"d",
".",
"puFromUser",
".",
"AddOrUpdate",
"(",
"user",
",",
"pu",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"port",
":=",
"range",
"tcpPorts",
"{",
"if",
"port",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"portSpec",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"port",
",",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"puInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"HostPU",
"{",
"d",
".",
"contextIDFromTCPPort",
".",
"AddPortSpecToEnd",
"(",
"portSpec",
")",
"\n",
"}",
"else",
"{",
"d",
".",
"contextIDFromTCPPort",
".",
"AddPortSpec",
"(",
"portSpec",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"port",
":=",
"range",
"udpPorts",
"{",
"portSpec",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"port",
",",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"// check for host pu and add its ports to the end.",
"if",
"puInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"HostPU",
"{",
"d",
".",
"contextIDFromUDPPort",
".",
"AddPortSpecToEnd",
"(",
"portSpec",
")",
"\n",
"}",
"else",
"{",
"d",
".",
"contextIDFromUDPPort",
".",
"AddPortSpec",
"(",
"portSpec",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"}",
"else",
"{",
"d",
".",
"puFromIP",
"=",
"pu",
"\n",
"}",
"\n\n",
"// pucontext launches a go routine to periodically",
"// lookup dns names. ctx cancel signals the go routine to exit",
"if",
"prevPU",
",",
"_",
":=",
"d",
".",
"puFromContextID",
".",
"Get",
"(",
"contextID",
")",
";",
"prevPU",
"!=",
"nil",
"{",
"prevPU",
".",
"(",
"*",
"pucontext",
".",
"PUContext",
")",
".",
"CancelFunc",
"(",
")",
"\n",
"}",
"\n\n",
"// Cache PU from contextID for management and policy updates",
"d",
".",
"puFromContextID",
".",
"AddOrUpdate",
"(",
"contextID",
",",
"pu",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Enforce implements the Enforce interface method and configures the data path for a new PU | [
"Enforce",
"implements",
"the",
"Enforce",
"interface",
"method",
"and",
"configures",
"the",
"data",
"path",
"for",
"a",
"new",
"PU"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath.go#L322-L386 |
7,043 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath.go | Unenforce | func (d *Datapath) Unenforce(contextID string) error {
var err error
puContext, err := d.puFromContextID.Get(contextID)
if err != nil {
return fmt.Errorf("contextid not found in enforcer: %s", err)
}
// Cleanup the IP based lookup
pu := puContext.(*pucontext.PUContext)
// Cleanup the mark information
if err = d.puFromMark.Remove(pu.Mark()); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("Mark", pu.Mark()),
zap.Error(err),
)
}
// Cleanup the username
if pu.Type() == common.UIDLoginPU {
if err = d.puFromUser.Remove(pu.Username()); err != nil {
zap.L().Debug("PU not found for the username", zap.String("username", pu.Username()))
}
}
// Cleanup the port cache
for _, port := range pu.TCPPorts() {
if port == "0" {
continue
}
if err := d.contextIDFromTCPPort.RemoveStringPorts(port); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("TCPPort", port),
zap.Error(err),
)
}
}
for _, port := range pu.UDPPorts() {
if err := d.contextIDFromUDPPort.RemoveStringPorts(port); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("UDPPort", port),
zap.Error(err),
)
}
}
// Cleanup the contextID cache
if err := d.puFromContextID.RemoveWithDelay(contextID, 10*time.Second); err != nil {
zap.L().Warn("Unable to remove context from cache",
zap.String("contextID", contextID),
zap.Error(err),
)
}
return nil
} | go | func (d *Datapath) Unenforce(contextID string) error {
var err error
puContext, err := d.puFromContextID.Get(contextID)
if err != nil {
return fmt.Errorf("contextid not found in enforcer: %s", err)
}
// Cleanup the IP based lookup
pu := puContext.(*pucontext.PUContext)
// Cleanup the mark information
if err = d.puFromMark.Remove(pu.Mark()); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("Mark", pu.Mark()),
zap.Error(err),
)
}
// Cleanup the username
if pu.Type() == common.UIDLoginPU {
if err = d.puFromUser.Remove(pu.Username()); err != nil {
zap.L().Debug("PU not found for the username", zap.String("username", pu.Username()))
}
}
// Cleanup the port cache
for _, port := range pu.TCPPorts() {
if port == "0" {
continue
}
if err := d.contextIDFromTCPPort.RemoveStringPorts(port); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("TCPPort", port),
zap.Error(err),
)
}
}
for _, port := range pu.UDPPorts() {
if err := d.contextIDFromUDPPort.RemoveStringPorts(port); err != nil {
zap.L().Debug("Unable to remove cache entry during unenforcement",
zap.String("UDPPort", port),
zap.Error(err),
)
}
}
// Cleanup the contextID cache
if err := d.puFromContextID.RemoveWithDelay(contextID, 10*time.Second); err != nil {
zap.L().Warn("Unable to remove context from cache",
zap.String("contextID", contextID),
zap.Error(err),
)
}
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"Unenforce",
"(",
"contextID",
"string",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"puContext",
",",
"err",
":=",
"d",
".",
"puFromContextID",
".",
"Get",
"(",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Cleanup the IP based lookup",
"pu",
":=",
"puContext",
".",
"(",
"*",
"pucontext",
".",
"PUContext",
")",
"\n\n",
"// Cleanup the mark information",
"if",
"err",
"=",
"d",
".",
"puFromMark",
".",
"Remove",
"(",
"pu",
".",
"Mark",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"pu",
".",
"Mark",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"// Cleanup the username",
"if",
"pu",
".",
"Type",
"(",
")",
"==",
"common",
".",
"UIDLoginPU",
"{",
"if",
"err",
"=",
"d",
".",
"puFromUser",
".",
"Remove",
"(",
"pu",
".",
"Username",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"pu",
".",
"Username",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// Cleanup the port cache",
"for",
"_",
",",
"port",
":=",
"range",
"pu",
".",
"TCPPorts",
"(",
")",
"{",
"if",
"port",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"contextIDFromTCPPort",
".",
"RemoveStringPorts",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"port",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"port",
":=",
"range",
"pu",
".",
"UDPPorts",
"(",
")",
"{",
"if",
"err",
":=",
"d",
".",
"contextIDFromUDPPort",
".",
"RemoveStringPorts",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"port",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Cleanup the contextID cache",
"if",
"err",
":=",
"d",
".",
"puFromContextID",
".",
"RemoveWithDelay",
"(",
"contextID",
",",
"10",
"*",
"time",
".",
"Second",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Unenforce removes the configuration for the given PU | [
"Unenforce",
"removes",
"the",
"configuration",
"for",
"the",
"given",
"PU"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath.go#L389-L447 |
7,044 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath.go | SetTargetNetworks | func (d *Datapath) SetTargetNetworks(cfg *runtime.Configuration) error {
networks := cfg.TCPTargetNetworks
if len(networks) == 0 {
networks = []string{"0.0.0.0/1", "128.0.0.0/1"}
}
d.targetNetworks = acls.NewACLCache()
targetacl := createPolicy(networks)
return d.targetNetworks.AddRuleList(targetacl)
} | go | func (d *Datapath) SetTargetNetworks(cfg *runtime.Configuration) error {
networks := cfg.TCPTargetNetworks
if len(networks) == 0 {
networks = []string{"0.0.0.0/1", "128.0.0.0/1"}
}
d.targetNetworks = acls.NewACLCache()
targetacl := createPolicy(networks)
return d.targetNetworks.AddRuleList(targetacl)
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"SetTargetNetworks",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"networks",
":=",
"cfg",
".",
"TCPTargetNetworks",
"\n\n",
"if",
"len",
"(",
"networks",
")",
"==",
"0",
"{",
"networks",
"=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"}",
"\n\n",
"d",
".",
"targetNetworks",
"=",
"acls",
".",
"NewACLCache",
"(",
")",
"\n",
"targetacl",
":=",
"createPolicy",
"(",
"networks",
")",
"\n",
"return",
"d",
".",
"targetNetworks",
".",
"AddRuleList",
"(",
"targetacl",
")",
"\n",
"}"
] | // SetTargetNetworks sets new target networks used by datapath | [
"SetTargetNetworks",
"sets",
"new",
"target",
"networks",
"used",
"by",
"datapath"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath.go#L450-L461 |
7,045 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath.go | Run | func (d *Datapath) Run(ctx context.Context) error {
zap.L().Debug("Start enforcer", zap.Int("mode", int(d.mode)))
if d.conntrack == nil {
conntrackClient, err := flowtracking.NewClient(ctx)
if err != nil {
return err
}
d.conntrack = conntrackClient
}
d.startApplicationInterceptor(ctx)
d.startNetworkInterceptor(ctx)
go d.nflogger.Run(ctx)
return nil
} | go | func (d *Datapath) Run(ctx context.Context) error {
zap.L().Debug("Start enforcer", zap.Int("mode", int(d.mode)))
if d.conntrack == nil {
conntrackClient, err := flowtracking.NewClient(ctx)
if err != nil {
return err
}
d.conntrack = conntrackClient
}
d.startApplicationInterceptor(ctx)
d.startNetworkInterceptor(ctx)
go d.nflogger.Run(ctx)
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Int",
"(",
"\"",
"\"",
",",
"int",
"(",
"d",
".",
"mode",
")",
")",
")",
"\n\n",
"if",
"d",
".",
"conntrack",
"==",
"nil",
"{",
"conntrackClient",
",",
"err",
":=",
"flowtracking",
".",
"NewClient",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"d",
".",
"conntrack",
"=",
"conntrackClient",
"\n",
"}",
"\n\n",
"d",
".",
"startApplicationInterceptor",
"(",
"ctx",
")",
"\n",
"d",
".",
"startNetworkInterceptor",
"(",
"ctx",
")",
"\n\n",
"go",
"d",
".",
"nflogger",
".",
"Run",
"(",
"ctx",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Run starts the application and network interceptors | [
"Run",
"starts",
"the",
"application",
"and",
"network",
"interceptors"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath.go#L470-L488 |
7,046 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath.go | contextFromIP | func (d *Datapath) contextFromIP(app bool, mark string, port uint16, protocol uint8) (*pucontext.PUContext, error) {
if d.puFromIP != nil {
return d.puFromIP, nil
}
if app {
pu, err := d.puFromMark.Get(mark)
if err != nil {
zap.L().Error("Unable to find context for application flow with mark",
zap.String("mark", mark),
zap.Int("protocol", int(protocol)),
zap.Int("port", int(port)),
)
return nil, errMarkNotFound
}
return pu.(*pucontext.PUContext), nil
}
// Network packets for non container traffic
if protocol == packet.IPProtocolTCP {
contextID, err := d.contextIDFromTCPPort.GetSpecValueFromPort(port)
if err != nil {
zap.L().Debug("Could not find PU context for TCP server port ", zap.Uint16("port", port))
return nil, errPortNotFound
}
pu, err := d.puFromContextID.Get(contextID)
if err != nil {
return nil, errContextIDNotFound
}
return pu.(*pucontext.PUContext), nil
}
if protocol == packet.IPProtocolUDP {
contextID, err := d.contextIDFromUDPPort.GetSpecValueFromPort(port)
if err != nil {
zap.L().Debug("Could not find PU context for UDP server port ", zap.Uint16("port", port))
return nil, errPortNotFound
}
pu, err := d.puFromContextID.Get(contextID)
if err != nil {
return nil, errContextIDNotFound
}
return pu.(*pucontext.PUContext), nil
}
zap.L().Error("Invalid protocol ", zap.Uint8("protocol", protocol))
return nil, errInvalidProtocol
} | go | func (d *Datapath) contextFromIP(app bool, mark string, port uint16, protocol uint8) (*pucontext.PUContext, error) {
if d.puFromIP != nil {
return d.puFromIP, nil
}
if app {
pu, err := d.puFromMark.Get(mark)
if err != nil {
zap.L().Error("Unable to find context for application flow with mark",
zap.String("mark", mark),
zap.Int("protocol", int(protocol)),
zap.Int("port", int(port)),
)
return nil, errMarkNotFound
}
return pu.(*pucontext.PUContext), nil
}
// Network packets for non container traffic
if protocol == packet.IPProtocolTCP {
contextID, err := d.contextIDFromTCPPort.GetSpecValueFromPort(port)
if err != nil {
zap.L().Debug("Could not find PU context for TCP server port ", zap.Uint16("port", port))
return nil, errPortNotFound
}
pu, err := d.puFromContextID.Get(contextID)
if err != nil {
return nil, errContextIDNotFound
}
return pu.(*pucontext.PUContext), nil
}
if protocol == packet.IPProtocolUDP {
contextID, err := d.contextIDFromUDPPort.GetSpecValueFromPort(port)
if err != nil {
zap.L().Debug("Could not find PU context for UDP server port ", zap.Uint16("port", port))
return nil, errPortNotFound
}
pu, err := d.puFromContextID.Get(contextID)
if err != nil {
return nil, errContextIDNotFound
}
return pu.(*pucontext.PUContext), nil
}
zap.L().Error("Invalid protocol ", zap.Uint8("protocol", protocol))
return nil, errInvalidProtocol
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"contextFromIP",
"(",
"app",
"bool",
",",
"mark",
"string",
",",
"port",
"uint16",
",",
"protocol",
"uint8",
")",
"(",
"*",
"pucontext",
".",
"PUContext",
",",
"error",
")",
"{",
"if",
"d",
".",
"puFromIP",
"!=",
"nil",
"{",
"return",
"d",
".",
"puFromIP",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"app",
"{",
"pu",
",",
"err",
":=",
"d",
".",
"puFromMark",
".",
"Get",
"(",
"mark",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"mark",
")",
",",
"zap",
".",
"Int",
"(",
"\"",
"\"",
",",
"int",
"(",
"protocol",
")",
")",
",",
"zap",
".",
"Int",
"(",
"\"",
"\"",
",",
"int",
"(",
"port",
")",
")",
",",
")",
"\n",
"return",
"nil",
",",
"errMarkNotFound",
"\n",
"}",
"\n",
"return",
"pu",
".",
"(",
"*",
"pucontext",
".",
"PUContext",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"// Network packets for non container traffic",
"if",
"protocol",
"==",
"packet",
".",
"IPProtocolTCP",
"{",
"contextID",
",",
"err",
":=",
"d",
".",
"contextIDFromTCPPort",
".",
"GetSpecValueFromPort",
"(",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Uint16",
"(",
"\"",
"\"",
",",
"port",
")",
")",
"\n",
"return",
"nil",
",",
"errPortNotFound",
"\n",
"}",
"\n\n",
"pu",
",",
"err",
":=",
"d",
".",
"puFromContextID",
".",
"Get",
"(",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errContextIDNotFound",
"\n",
"}",
"\n",
"return",
"pu",
".",
"(",
"*",
"pucontext",
".",
"PUContext",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"protocol",
"==",
"packet",
".",
"IPProtocolUDP",
"{",
"contextID",
",",
"err",
":=",
"d",
".",
"contextIDFromUDPPort",
".",
"GetSpecValueFromPort",
"(",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Uint16",
"(",
"\"",
"\"",
",",
"port",
")",
")",
"\n",
"return",
"nil",
",",
"errPortNotFound",
"\n",
"}",
"\n\n",
"pu",
",",
"err",
":=",
"d",
".",
"puFromContextID",
".",
"Get",
"(",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errContextIDNotFound",
"\n",
"}",
"\n",
"return",
"pu",
".",
"(",
"*",
"pucontext",
".",
"PUContext",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Uint8",
"(",
"\"",
"\"",
",",
"protocol",
")",
")",
"\n\n",
"return",
"nil",
",",
"errInvalidProtocol",
"\n",
"}"
] | // contextFromIP returns the PU context from the default IP if remote. Otherwise
// it returns the context from the port or mark values of the packet. Synack
// packets are again special and the flow is reversed. If a container doesn't supply
// its IP information, we use the default IP. This will only work with remotes
// and Linux processes. | [
"contextFromIP",
"returns",
"the",
"PU",
"context",
"from",
"the",
"default",
"IP",
"if",
"remote",
".",
"Otherwise",
"it",
"returns",
"the",
"context",
"from",
"the",
"port",
"or",
"mark",
"values",
"of",
"the",
"packet",
".",
"Synack",
"packets",
"are",
"again",
"special",
"and",
"the",
"flow",
"is",
"reversed",
".",
"If",
"a",
"container",
"doesn",
"t",
"supply",
"its",
"IP",
"information",
"we",
"use",
"the",
"default",
"IP",
".",
"This",
"will",
"only",
"work",
"with",
"remotes",
"and",
"Linux",
"processes",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath.go#L545-L596 |
7,047 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | AssignMark | func (s *netCls) AssignMark(cgroupname string, mark uint64) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cgroup does not exist: %s", err)
}
//16 is the base since the mark file expects hexadecimal values
markval := "0x" + (strconv.FormatUint(mark, 16))
if err := ioutil.WriteFile(filepath.Join(basePath, s.TriremePath, cgroupname, markFile), []byte(markval), 0644); err != nil {
return fmt.Errorf("failed to write to net_cls.classid file for new cgroup: %s", err)
}
return nil
} | go | func (s *netCls) AssignMark(cgroupname string, mark uint64) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cgroup does not exist: %s", err)
}
//16 is the base since the mark file expects hexadecimal values
markval := "0x" + (strconv.FormatUint(mark, 16))
if err := ioutil.WriteFile(filepath.Join(basePath, s.TriremePath, cgroupname, markFile), []byte(markval), 0644); err != nil {
return fmt.Errorf("failed to write to net_cls.classid file for new cgroup: %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"AssignMark",
"(",
"cgroupname",
"string",
",",
"mark",
"uint64",
")",
"error",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"//16 is the base since the mark file expects hexadecimal values",
"markval",
":=",
"\"",
"\"",
"+",
"(",
"strconv",
".",
"FormatUint",
"(",
"mark",
",",
"16",
")",
")",
"\n\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
",",
"markFile",
")",
",",
"[",
"]",
"byte",
"(",
"markval",
")",
",",
"0644",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //AssignMark writes the mark value to net_cls.classid file. | [
"AssignMark",
"writes",
"the",
"mark",
"value",
"to",
"net_cls",
".",
"classid",
"file",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L76-L91 |
7,048 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | AddProcess | func (s *netCls) AddProcess(cgroupname string, pid int) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cannot add process. cgroup does not exist: %s", err)
}
PID := []byte(strconv.Itoa(pid))
if err := syscall.Kill(pid, 0); err != nil {
return nil
}
if err := ioutil.WriteFile(filepath.Join(basePath, s.TriremePath, cgroupname, procs), PID, 0644); err != nil {
return fmt.Errorf("cannot add process: %s", err)
}
return nil
} | go | func (s *netCls) AddProcess(cgroupname string, pid int) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cannot add process. cgroup does not exist: %s", err)
}
PID := []byte(strconv.Itoa(pid))
if err := syscall.Kill(pid, 0); err != nil {
return nil
}
if err := ioutil.WriteFile(filepath.Join(basePath, s.TriremePath, cgroupname, procs), PID, 0644); err != nil {
return fmt.Errorf("cannot add process: %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"AddProcess",
"(",
"cgroupname",
"string",
",",
"pid",
"int",
")",
"error",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"PID",
":=",
"[",
"]",
"byte",
"(",
"strconv",
".",
"Itoa",
"(",
"pid",
")",
")",
"\n",
"if",
"err",
":=",
"syscall",
".",
"Kill",
"(",
"pid",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
",",
"procs",
")",
",",
"PID",
",",
"0644",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AddProcess adds the process to the net_cls group | [
"AddProcess",
"adds",
"the",
"process",
"to",
"the",
"net_cls",
"group"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L94-L111 |
7,049 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | RemoveProcess | func (s *netCls) RemoveProcess(cgroupname string, pid int) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cannot clean up process. cgroup does not exist: %s", err)
}
data, err := ioutil.ReadFile(filepath.Join(basePath, procs))
if err != nil {
return fmt.Errorf("cannot cleanup process: %s", err)
}
if !strings.Contains(string(data), strconv.Itoa(pid)) {
return errors.New("cannot cleanup process. process is not a part of this cgroup")
}
if err := ioutil.WriteFile(filepath.Join(basePath, procs), []byte(strconv.Itoa(pid)), 0644); err != nil {
return fmt.Errorf("cannot clean up process: %s", err)
}
return nil
} | go | func (s *netCls) RemoveProcess(cgroupname string, pid int) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return fmt.Errorf("cannot clean up process. cgroup does not exist: %s", err)
}
data, err := ioutil.ReadFile(filepath.Join(basePath, procs))
if err != nil {
return fmt.Errorf("cannot cleanup process: %s", err)
}
if !strings.Contains(string(data), strconv.Itoa(pid)) {
return errors.New("cannot cleanup process. process is not a part of this cgroup")
}
if err := ioutil.WriteFile(filepath.Join(basePath, procs), []byte(strconv.Itoa(pid)), 0644); err != nil {
return fmt.Errorf("cannot clean up process: %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"RemoveProcess",
"(",
"cgroupname",
"string",
",",
"pid",
"int",
")",
"error",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"procs",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"string",
"(",
"data",
")",
",",
"strconv",
".",
"Itoa",
"(",
"pid",
")",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"procs",
")",
",",
"[",
"]",
"byte",
"(",
"strconv",
".",
"Itoa",
"(",
"pid",
")",
")",
",",
"0644",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //RemoveProcess removes the process from the cgroup by writing the pid to the
//top of net_cls cgroup cgroup.procs | [
"RemoveProcess",
"removes",
"the",
"process",
"from",
"the",
"cgroup",
"by",
"writing",
"the",
"pid",
"to",
"the",
"top",
"of",
"net_cls",
"cgroup",
"cgroup",
".",
"procs"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L115-L135 |
7,050 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | DeleteCgroup | func (s *netCls) DeleteCgroup(cgroupname string) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
zap.L().Debug("Group already deleted", zap.Error(err))
return nil
}
err = os.Remove(filepath.Join(basePath, s.TriremePath, cgroupname))
if err != nil {
return fmt.Errorf("unable to delete cgroup %s: %s", cgroupname, err)
}
return nil
} | go | func (s *netCls) DeleteCgroup(cgroupname string) error {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
zap.L().Debug("Group already deleted", zap.Error(err))
return nil
}
err = os.Remove(filepath.Join(basePath, s.TriremePath, cgroupname))
if err != nil {
return fmt.Errorf("unable to delete cgroup %s: %s", cgroupname, err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"DeleteCgroup",
"(",
"cgroupname",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
"=",
"os",
".",
"Remove",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cgroupname",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // DeleteCgroup assumes the cgroup is already empty and destroys the directory structure.
// It will return an error if the group is not empty. Use RempoveProcess to remove all processes
// Before we try deletion | [
"DeleteCgroup",
"assumes",
"the",
"cgroup",
"is",
"already",
"empty",
"and",
"destroys",
"the",
"directory",
"structure",
".",
"It",
"will",
"return",
"an",
"error",
"if",
"the",
"group",
"is",
"not",
"empty",
".",
"Use",
"RempoveProcess",
"to",
"remove",
"all",
"processes",
"Before",
"we",
"try",
"deletion"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L140-L154 |
7,051 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | Deletebasepath | func (s *netCls) Deletebasepath(cgroupName string) bool {
if cgroupName == s.TriremePath {
if err := os.Remove(filepath.Join(basePath, cgroupName)); err != nil {
zap.L().Error("Error when removing Trireme Base Path", zap.Error(err))
}
return true
}
return false
} | go | func (s *netCls) Deletebasepath(cgroupName string) bool {
if cgroupName == s.TriremePath {
if err := os.Remove(filepath.Join(basePath, cgroupName)); err != nil {
zap.L().Error("Error when removing Trireme Base Path", zap.Error(err))
}
return true
}
return false
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"Deletebasepath",
"(",
"cgroupName",
"string",
")",
"bool",
"{",
"if",
"cgroupName",
"==",
"s",
".",
"TriremePath",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"cgroupName",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | //Deletebasepath removes the base aporeto directory which comes as a separate event when we are not managing any processes | [
"Deletebasepath",
"removes",
"the",
"base",
"aporeto",
"directory",
"which",
"comes",
"as",
"a",
"separate",
"event",
"when",
"we",
"are",
"not",
"managing",
"any",
"processes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L157-L167 |
7,052 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | ListCgroupProcesses | func (s *netCls) ListCgroupProcesses(cgroupname string) ([]string, error) {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return []string{}, fmt.Errorf("cgroup %s does not exist: %s", cgroupname, err)
}
data, err := ioutil.ReadFile(filepath.Join(basePath, s.TriremePath, cgroupname, "cgroup.procs"))
if err != nil {
return []string{}, fmt.Errorf("cannot read procs file: %s", err)
}
procs := []string{}
for _, line := range strings.Split(string(data), "\n") {
if len(line) > 0 {
procs = append(procs, line)
}
}
return procs, nil
} | go | func (s *netCls) ListCgroupProcesses(cgroupname string) ([]string, error) {
_, err := os.Stat(filepath.Join(basePath, s.TriremePath, cgroupname))
if os.IsNotExist(err) {
return []string{}, fmt.Errorf("cgroup %s does not exist: %s", cgroupname, err)
}
data, err := ioutil.ReadFile(filepath.Join(basePath, s.TriremePath, cgroupname, "cgroup.procs"))
if err != nil {
return []string{}, fmt.Errorf("cannot read procs file: %s", err)
}
procs := []string{}
for _, line := range strings.Split(string(data), "\n") {
if len(line) > 0 {
procs = append(procs, line)
}
}
return procs, nil
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"ListCgroupProcesses",
"(",
"cgroupname",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
")",
")",
"\n\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cgroupname",
",",
"err",
")",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"cgroupname",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"procs",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"string",
"(",
"data",
")",
",",
"\"",
"\\n",
"\"",
")",
"{",
"if",
"len",
"(",
"line",
")",
">",
"0",
"{",
"procs",
"=",
"append",
"(",
"procs",
",",
"line",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"procs",
",",
"nil",
"\n",
"}"
] | // ListCgroupProcesses returns lists of processes in the cgroup | [
"ListCgroupProcesses",
"returns",
"lists",
"of",
"processes",
"in",
"the",
"cgroup"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L170-L192 |
7,053 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | ListAllCgroups | func (s *netCls) ListAllCgroups(path string) []string {
cgroups, err := ioutil.ReadDir(filepath.Join(basePath, s.TriremePath, path))
if err != nil {
return []string{}
}
names := make([]string, len(cgroups))
for i := 0; i < len(cgroups); i++ {
names[i] = cgroups[i].Name()
}
return names
} | go | func (s *netCls) ListAllCgroups(path string) []string {
cgroups, err := ioutil.ReadDir(filepath.Join(basePath, s.TriremePath, path))
if err != nil {
return []string{}
}
names := make([]string, len(cgroups))
for i := 0; i < len(cgroups); i++ {
names[i] = cgroups[i].Name()
}
return names
} | [
"func",
"(",
"s",
"*",
"netCls",
")",
"ListAllCgroups",
"(",
"path",
"string",
")",
"[",
"]",
"string",
"{",
"cgroups",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"s",
".",
"TriremePath",
",",
"path",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"names",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"cgroups",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"cgroups",
")",
";",
"i",
"++",
"{",
"names",
"[",
"i",
"]",
"=",
"cgroups",
"[",
"i",
"]",
".",
"Name",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"names",
"\n",
"}"
] | // ListAllCgroups returns a list of the cgroups that are managed in the Trireme path | [
"ListAllCgroups",
"returns",
"a",
"list",
"of",
"the",
"cgroups",
"that",
"are",
"managed",
"in",
"the",
"Trireme",
"path"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L195-L208 |
7,054 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | NewDockerCgroupNetController | func NewDockerCgroupNetController() Cgroupnetcls {
controller := &netCls{
markchan: make(chan uint64),
ReleaseAgentPath: "",
TriremePath: "",
}
return controller
} | go | func NewDockerCgroupNetController() Cgroupnetcls {
controller := &netCls{
markchan: make(chan uint64),
ReleaseAgentPath: "",
TriremePath: "",
}
return controller
} | [
"func",
"NewDockerCgroupNetController",
"(",
")",
"Cgroupnetcls",
"{",
"controller",
":=",
"&",
"netCls",
"{",
"markchan",
":",
"make",
"(",
"chan",
"uint64",
")",
",",
"ReleaseAgentPath",
":",
"\"",
"\"",
",",
"TriremePath",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"return",
"controller",
"\n",
"}"
] | // NewDockerCgroupNetController returns a handle to call functions on the cgroup net_cls controller | [
"NewDockerCgroupNetController",
"returns",
"a",
"handle",
"to",
"call",
"functions",
"on",
"the",
"cgroup",
"net_cls",
"controller"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L264-L273 |
7,055 | aporeto-inc/trireme-lib | utils/cgnetcls/cgnetcls.go | NewCgroupNetController | func NewCgroupNetController(triremepath string, releasePath string) Cgroupnetcls {
if !mounted {
mounted = true
if err := mountCgroupController(); err != nil {
zap.L().Error("Unable to mount net_cls controller - Linux process isolation not possible",
zap.Error(err))
}
}
binpath, _ := osext.Executable()
controller := &netCls{
markchan: make(chan uint64),
ReleaseAgentPath: binpath,
TriremePath: "",
}
if releasePath != "" {
controller.ReleaseAgentPath = releasePath
}
if triremepath != "" {
controller.TriremePath = triremepath
}
return controller
} | go | func NewCgroupNetController(triremepath string, releasePath string) Cgroupnetcls {
if !mounted {
mounted = true
if err := mountCgroupController(); err != nil {
zap.L().Error("Unable to mount net_cls controller - Linux process isolation not possible",
zap.Error(err))
}
}
binpath, _ := osext.Executable()
controller := &netCls{
markchan: make(chan uint64),
ReleaseAgentPath: binpath,
TriremePath: "",
}
if releasePath != "" {
controller.ReleaseAgentPath = releasePath
}
if triremepath != "" {
controller.TriremePath = triremepath
}
return controller
} | [
"func",
"NewCgroupNetController",
"(",
"triremepath",
"string",
",",
"releasePath",
"string",
")",
"Cgroupnetcls",
"{",
"if",
"!",
"mounted",
"{",
"mounted",
"=",
"true",
"\n",
"if",
"err",
":=",
"mountCgroupController",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"binpath",
",",
"_",
":=",
"osext",
".",
"Executable",
"(",
")",
"\n",
"controller",
":=",
"&",
"netCls",
"{",
"markchan",
":",
"make",
"(",
"chan",
"uint64",
")",
",",
"ReleaseAgentPath",
":",
"binpath",
",",
"TriremePath",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"if",
"releasePath",
"!=",
"\"",
"\"",
"{",
"controller",
".",
"ReleaseAgentPath",
"=",
"releasePath",
"\n",
"}",
"\n\n",
"if",
"triremepath",
"!=",
"\"",
"\"",
"{",
"controller",
".",
"TriremePath",
"=",
"triremepath",
"\n",
"}",
"\n\n",
"return",
"controller",
"\n",
"}"
] | //NewCgroupNetController returns a handle to call functions on the cgroup net_cls controller | [
"NewCgroupNetController",
"returns",
"a",
"handle",
"to",
"call",
"functions",
"on",
"the",
"cgroup",
"net_cls",
"controller"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/cgnetcls.go#L276-L300 |
7,056 | aporeto-inc/trireme-lib | controller/pkg/servicetokens/servicetokens.go | NewVerifier | func NewVerifier(s secrets.Secrets, globalCertificate *x509.Certificate) *Verifier {
return &Verifier{
secrets: s,
globalCert: globalCertificate,
// tokenCache will cache the token results to accelerate performance
tokenCache: gcache.New(2048).LRU().Expiration(20 * time.Second).Build(),
}
} | go | func NewVerifier(s secrets.Secrets, globalCertificate *x509.Certificate) *Verifier {
return &Verifier{
secrets: s,
globalCert: globalCertificate,
// tokenCache will cache the token results to accelerate performance
tokenCache: gcache.New(2048).LRU().Expiration(20 * time.Second).Build(),
}
} | [
"func",
"NewVerifier",
"(",
"s",
"secrets",
".",
"Secrets",
",",
"globalCertificate",
"*",
"x509",
".",
"Certificate",
")",
"*",
"Verifier",
"{",
"return",
"&",
"Verifier",
"{",
"secrets",
":",
"s",
",",
"globalCert",
":",
"globalCertificate",
",",
"// tokenCache will cache the token results to accelerate performance",
"tokenCache",
":",
"gcache",
".",
"New",
"(",
"2048",
")",
".",
"LRU",
"(",
")",
".",
"Expiration",
"(",
"20",
"*",
"time",
".",
"Second",
")",
".",
"Build",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewVerifier creates a new Aporeto JWT Verifier. The globalCertificate is optional
// and is needed for configurations that do not transmit the token over the wire. | [
"NewVerifier",
"creates",
"a",
"new",
"Aporeto",
"JWT",
"Verifier",
".",
"The",
"globalCertificate",
"is",
"optional",
"and",
"is",
"needed",
"for",
"configurations",
"that",
"do",
"not",
"transmit",
"the",
"token",
"over",
"the",
"wire",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/servicetokens/servicetokens.go#L39-L46 |
7,057 | aporeto-inc/trireme-lib | controller/pkg/servicetokens/servicetokens.go | UpdateSecrets | func (p *Verifier) UpdateSecrets(s secrets.Secrets, globalCert *x509.Certificate) {
p.Lock()
defer p.Unlock()
p.secrets = s
p.globalCert = globalCert
} | go | func (p *Verifier) UpdateSecrets(s secrets.Secrets, globalCert *x509.Certificate) {
p.Lock()
defer p.Unlock()
p.secrets = s
p.globalCert = globalCert
} | [
"func",
"(",
"p",
"*",
"Verifier",
")",
"UpdateSecrets",
"(",
"s",
"secrets",
".",
"Secrets",
",",
"globalCert",
"*",
"x509",
".",
"Certificate",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"secrets",
"=",
"s",
"\n",
"p",
".",
"globalCert",
"=",
"globalCert",
"\n",
"}"
] | // UpdateSecrets updates the secrets of the token Verifier. | [
"UpdateSecrets",
"updates",
"the",
"secrets",
"of",
"the",
"token",
"Verifier",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/servicetokens/servicetokens.go#L108-L114 |
7,058 | aporeto-inc/trireme-lib | controller/pkg/servicetokens/servicetokens.go | CreateAndSign | func CreateAndSign(server string, profile, scopes []string, id string, validity time.Duration, gkey interface{}) (string, error) {
key, ok := gkey.(*ecdsa.PrivateKey)
if !ok {
return "", fmt.Errorf("Not a valid private key format")
}
if token, err := localCache.Get(id); err == nil {
return token.(string), nil
}
claims := &JWTClaims{
StandardClaims: jwt.StandardClaims{
Issuer: server,
ExpiresAt: time.Now().Add(validity).Unix(),
Subject: id,
},
Profile: profile,
Scopes: scopes,
}
token, err := jwt.NewWithClaims(jwt.SigningMethodES256, claims).SignedString(key)
if err != nil {
return "", err
}
localCache.AddOrUpdate(id, token)
return token, nil
} | go | func CreateAndSign(server string, profile, scopes []string, id string, validity time.Duration, gkey interface{}) (string, error) {
key, ok := gkey.(*ecdsa.PrivateKey)
if !ok {
return "", fmt.Errorf("Not a valid private key format")
}
if token, err := localCache.Get(id); err == nil {
return token.(string), nil
}
claims := &JWTClaims{
StandardClaims: jwt.StandardClaims{
Issuer: server,
ExpiresAt: time.Now().Add(validity).Unix(),
Subject: id,
},
Profile: profile,
Scopes: scopes,
}
token, err := jwt.NewWithClaims(jwt.SigningMethodES256, claims).SignedString(key)
if err != nil {
return "", err
}
localCache.AddOrUpdate(id, token)
return token, nil
} | [
"func",
"CreateAndSign",
"(",
"server",
"string",
",",
"profile",
",",
"scopes",
"[",
"]",
"string",
",",
"id",
"string",
",",
"validity",
"time",
".",
"Duration",
",",
"gkey",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"error",
")",
"{",
"key",
",",
"ok",
":=",
"gkey",
".",
"(",
"*",
"ecdsa",
".",
"PrivateKey",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"token",
",",
"err",
":=",
"localCache",
".",
"Get",
"(",
"id",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"token",
".",
"(",
"string",
")",
",",
"nil",
"\n",
"}",
"\n",
"claims",
":=",
"&",
"JWTClaims",
"{",
"StandardClaims",
":",
"jwt",
".",
"StandardClaims",
"{",
"Issuer",
":",
"server",
",",
"ExpiresAt",
":",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"validity",
")",
".",
"Unix",
"(",
")",
",",
"Subject",
":",
"id",
",",
"}",
",",
"Profile",
":",
"profile",
",",
"Scopes",
":",
"scopes",
",",
"}",
"\n\n",
"token",
",",
"err",
":=",
"jwt",
".",
"NewWithClaims",
"(",
"jwt",
".",
"SigningMethodES256",
",",
"claims",
")",
".",
"SignedString",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"localCache",
".",
"AddOrUpdate",
"(",
"id",
",",
"token",
")",
"\n",
"return",
"token",
",",
"nil",
"\n",
"}"
] | // CreateAndSign creates a new JWT token based on the Aporeto identities. | [
"CreateAndSign",
"creates",
"a",
"new",
"JWT",
"token",
"based",
"on",
"the",
"Aporeto",
"identities",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/servicetokens/servicetokens.go#L117-L142 |
7,059 | aporeto-inc/trireme-lib | monitor/internal/cni/processor.go | generateContextID | func generateContextID(eventInfo *common.EventInfo) (string, error) {
if eventInfo.PUID == "" {
return "", errors.New("puid is empty from event info")
}
if len(eventInfo.PUID) < 12 {
return "", errors.New("puid smaller than 12 characters")
}
return eventInfo.PUID[:12], nil
} | go | func generateContextID(eventInfo *common.EventInfo) (string, error) {
if eventInfo.PUID == "" {
return "", errors.New("puid is empty from event info")
}
if len(eventInfo.PUID) < 12 {
return "", errors.New("puid smaller than 12 characters")
}
return eventInfo.PUID[:12], nil
} | [
"func",
"generateContextID",
"(",
"eventInfo",
"*",
"common",
".",
"EventInfo",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"eventInfo",
".",
"PUID",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"eventInfo",
".",
"PUID",
")",
"<",
"12",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"eventInfo",
".",
"PUID",
"[",
":",
"12",
"]",
",",
"nil",
"\n",
"}"
] | // generateContextID creates the contextID from the event information | [
"generateContextID",
"creates",
"the",
"contextID",
"from",
"the",
"event",
"information"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/cni/processor.go#L88-L99 |
7,060 | aporeto-inc/trireme-lib | controller/pkg/flowtracking/flowtracking.go | NewClient | func NewClient(ctx context.Context) (*Client, error) {
c, err := conntrack.Dial(&netlink.Config{})
if err != nil {
return nil, fmt.Errorf("flow tracker is unable to dial netlink: %s", err)
}
client := &Client{conn: c}
go func() {
<-ctx.Done()
client.conn.Close() // nolint errcheck
}()
return client, nil
} | go | func NewClient(ctx context.Context) (*Client, error) {
c, err := conntrack.Dial(&netlink.Config{})
if err != nil {
return nil, fmt.Errorf("flow tracker is unable to dial netlink: %s", err)
}
client := &Client{conn: c}
go func() {
<-ctx.Done()
client.conn.Close() // nolint errcheck
}()
return client, nil
} | [
"func",
"NewClient",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"conntrack",
".",
"Dial",
"(",
"&",
"netlink",
".",
"Config",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"client",
":=",
"&",
"Client",
"{",
"conn",
":",
"c",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"client",
".",
"conn",
".",
"Close",
"(",
")",
"// nolint errcheck",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // NewClient creates a new flow tracking client. s | [
"NewClient",
"creates",
"a",
"new",
"flow",
"tracking",
"client",
".",
"s"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/flowtracking/flowtracking.go#L20-L33 |
7,061 | aporeto-inc/trireme-lib | controller/pkg/flowtracking/flowtracking.go | UpdateApplicationFlowMark | func (c *Client) UpdateApplicationFlowMark(ipSrc, ipDst net.IP, protonum uint8, srcport, dstport uint16, newmark uint32) error {
f := conntrack.NewFlow(protonum, 0, ipSrc, ipDst, srcport, dstport, 0, newmark)
return c.conn.Update(f)
} | go | func (c *Client) UpdateApplicationFlowMark(ipSrc, ipDst net.IP, protonum uint8, srcport, dstport uint16, newmark uint32) error {
f := conntrack.NewFlow(protonum, 0, ipSrc, ipDst, srcport, dstport, 0, newmark)
return c.conn.Update(f)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateApplicationFlowMark",
"(",
"ipSrc",
",",
"ipDst",
"net",
".",
"IP",
",",
"protonum",
"uint8",
",",
"srcport",
",",
"dstport",
"uint16",
",",
"newmark",
"uint32",
")",
"error",
"{",
"f",
":=",
"conntrack",
".",
"NewFlow",
"(",
"protonum",
",",
"0",
",",
"ipSrc",
",",
"ipDst",
",",
"srcport",
",",
"dstport",
",",
"0",
",",
"newmark",
")",
"\n\n",
"return",
"c",
".",
"conn",
".",
"Update",
"(",
"f",
")",
"\n",
"}"
] | // UpdateApplicationFlowMark will update the mark for a flow based on the packet information
// received from an application. It will use the forward entries of conntrack for that. | [
"UpdateApplicationFlowMark",
"will",
"update",
"the",
"mark",
"for",
"a",
"flow",
"based",
"on",
"the",
"packet",
"information",
"received",
"from",
"an",
"application",
".",
"It",
"will",
"use",
"the",
"forward",
"entries",
"of",
"conntrack",
"for",
"that",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/flowtracking/flowtracking.go#L62-L67 |
7,062 | aporeto-inc/trireme-lib | controller/pkg/flowtracking/flowtracking.go | newReplyFlow | func newReplyFlow(proto uint8, status conntrack.StatusFlag, srcAddr, destAddr net.IP, srcPort, destPort uint16, timeout, mark uint32) conntrack.Flow {
var f conntrack.Flow
f.Status.Value = status
f.Timeout = timeout
f.Mark = mark
// Set up TupleReply with source and destination inverted
f.TupleReply.IP.SourceAddress = srcAddr
f.TupleReply.IP.DestinationAddress = destAddr
f.TupleReply.Proto.SourcePort = srcPort
f.TupleReply.Proto.DestinationPort = destPort
f.TupleReply.Proto.Protocol = proto
return f
} | go | func newReplyFlow(proto uint8, status conntrack.StatusFlag, srcAddr, destAddr net.IP, srcPort, destPort uint16, timeout, mark uint32) conntrack.Flow {
var f conntrack.Flow
f.Status.Value = status
f.Timeout = timeout
f.Mark = mark
// Set up TupleReply with source and destination inverted
f.TupleReply.IP.SourceAddress = srcAddr
f.TupleReply.IP.DestinationAddress = destAddr
f.TupleReply.Proto.SourcePort = srcPort
f.TupleReply.Proto.DestinationPort = destPort
f.TupleReply.Proto.Protocol = proto
return f
} | [
"func",
"newReplyFlow",
"(",
"proto",
"uint8",
",",
"status",
"conntrack",
".",
"StatusFlag",
",",
"srcAddr",
",",
"destAddr",
"net",
".",
"IP",
",",
"srcPort",
",",
"destPort",
"uint16",
",",
"timeout",
",",
"mark",
"uint32",
")",
"conntrack",
".",
"Flow",
"{",
"var",
"f",
"conntrack",
".",
"Flow",
"\n\n",
"f",
".",
"Status",
".",
"Value",
"=",
"status",
"\n\n",
"f",
".",
"Timeout",
"=",
"timeout",
"\n",
"f",
".",
"Mark",
"=",
"mark",
"\n\n",
"// Set up TupleReply with source and destination inverted",
"f",
".",
"TupleReply",
".",
"IP",
".",
"SourceAddress",
"=",
"srcAddr",
"\n",
"f",
".",
"TupleReply",
".",
"IP",
".",
"DestinationAddress",
"=",
"destAddr",
"\n",
"f",
".",
"TupleReply",
".",
"Proto",
".",
"SourcePort",
"=",
"srcPort",
"\n",
"f",
".",
"TupleReply",
".",
"Proto",
".",
"DestinationPort",
"=",
"destPort",
"\n",
"f",
".",
"TupleReply",
".",
"Proto",
".",
"Protocol",
"=",
"proto",
"\n\n",
"return",
"f",
"\n",
"}"
] | // newReplyFlow will create a flow based on the reply tuple only. This will help us
// update the mark without requiring knowledge of nats. | [
"newReplyFlow",
"will",
"create",
"a",
"flow",
"based",
"on",
"the",
"reply",
"tuple",
"only",
".",
"This",
"will",
"help",
"us",
"update",
"the",
"mark",
"without",
"requiring",
"knowledge",
"of",
"nats",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/flowtracking/flowtracking.go#L71-L88 |
7,063 | aporeto-inc/trireme-lib | monitor/config/config.go | String | func (c *MonitorConfig) String() string {
buf := fmt.Sprintf("MergeTags:[%s] ", strings.Join(c.MergeTags, ","))
buf += fmt.Sprintf("Common:%+v ", c.Common)
buf += fmt.Sprintf("Monitors:{")
for k, v := range c.Monitors {
buf += fmt.Sprintf("{%d:%+v},", k, v)
}
buf += fmt.Sprintf("}")
return buf
} | go | func (c *MonitorConfig) String() string {
buf := fmt.Sprintf("MergeTags:[%s] ", strings.Join(c.MergeTags, ","))
buf += fmt.Sprintf("Common:%+v ", c.Common)
buf += fmt.Sprintf("Monitors:{")
for k, v := range c.Monitors {
buf += fmt.Sprintf("{%d:%+v},", k, v)
}
buf += fmt.Sprintf("}")
return buf
} | [
"func",
"(",
"c",
"*",
"MonitorConfig",
")",
"String",
"(",
")",
"string",
"{",
"buf",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"c",
".",
"MergeTags",
",",
"\"",
"\"",
")",
")",
"\n",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"Common",
")",
"\n",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"c",
".",
"Monitors",
"{",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"buf",
"\n",
"}"
] | // String returns the configuration in string | [
"String",
"returns",
"the",
"configuration",
"in",
"string"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/config/config.go#L34-L43 |
7,064 | aporeto-inc/trireme-lib | monitor/config/config.go | IsComplete | func (c *ProcessorConfig) IsComplete() error {
if c.Collector == nil {
return fmt.Errorf("Missing configuration: collector")
}
if c.Policy == nil {
return fmt.Errorf("Missing configuration: puHandler")
}
return nil
} | go | func (c *ProcessorConfig) IsComplete() error {
if c.Collector == nil {
return fmt.Errorf("Missing configuration: collector")
}
if c.Policy == nil {
return fmt.Errorf("Missing configuration: puHandler")
}
return nil
} | [
"func",
"(",
"c",
"*",
"ProcessorConfig",
")",
"IsComplete",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Collector",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Policy",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // IsComplete checks if configuration is complete | [
"IsComplete",
"checks",
"if",
"configuration",
"is",
"complete"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/config/config.go#L53-L64 |
7,065 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go | CollectFlowEvent | func (c *collectorImpl) CollectFlowEvent(record *collector.FlowRecord) {
hash := collector.StatsFlowHash(record)
// If flow event doesn't have a count make it equal to 1. At least one flow is collected
if record.Count == 0 {
record.Count = 1
}
c.Lock()
defer c.Unlock()
if r, ok := c.Flows[hash]; ok {
r.Count = r.Count + record.Count
return
}
c.Flows[hash] = record
c.Flows[hash].Tags = record.Tags
} | go | func (c *collectorImpl) CollectFlowEvent(record *collector.FlowRecord) {
hash := collector.StatsFlowHash(record)
// If flow event doesn't have a count make it equal to 1. At least one flow is collected
if record.Count == 0 {
record.Count = 1
}
c.Lock()
defer c.Unlock()
if r, ok := c.Flows[hash]; ok {
r.Count = r.Count + record.Count
return
}
c.Flows[hash] = record
c.Flows[hash].Tags = record.Tags
} | [
"func",
"(",
"c",
"*",
"collectorImpl",
")",
"CollectFlowEvent",
"(",
"record",
"*",
"collector",
".",
"FlowRecord",
")",
"{",
"hash",
":=",
"collector",
".",
"StatsFlowHash",
"(",
"record",
")",
"\n\n",
"// If flow event doesn't have a count make it equal to 1. At least one flow is collected",
"if",
"record",
".",
"Count",
"==",
"0",
"{",
"record",
".",
"Count",
"=",
"1",
"\n",
"}",
"\n\n",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"r",
",",
"ok",
":=",
"c",
".",
"Flows",
"[",
"hash",
"]",
";",
"ok",
"{",
"r",
".",
"Count",
"=",
"r",
".",
"Count",
"+",
"record",
".",
"Count",
"\n",
"return",
"\n",
"}",
"\n\n",
"c",
".",
"Flows",
"[",
"hash",
"]",
"=",
"record",
"\n\n",
"c",
".",
"Flows",
"[",
"hash",
"]",
".",
"Tags",
"=",
"record",
".",
"Tags",
"\n",
"}"
] | // CollectFlowEvent collects a new flow event and adds it to a local list it shares with SendStats | [
"CollectFlowEvent",
"collects",
"a",
"new",
"flow",
"event",
"and",
"adds",
"it",
"to",
"a",
"local",
"list",
"it",
"shares",
"with",
"SendStats"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go#L9-L29 |
7,066 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go | CollectUserEvent | func (c *collectorImpl) CollectUserEvent(record *collector.UserRecord) {
if err := collector.StatsUserHash(record); err != nil {
zap.L().Error("Cannot store user record", zap.Error(err))
return
}
c.Lock()
defer c.Unlock()
if _, ok := c.ProcessedUsers[record.ID]; !ok {
c.Users[record.ID] = record
c.ProcessedUsers[record.ID] = true
}
} | go | func (c *collectorImpl) CollectUserEvent(record *collector.UserRecord) {
if err := collector.StatsUserHash(record); err != nil {
zap.L().Error("Cannot store user record", zap.Error(err))
return
}
c.Lock()
defer c.Unlock()
if _, ok := c.ProcessedUsers[record.ID]; !ok {
c.Users[record.ID] = record
c.ProcessedUsers[record.ID] = true
}
} | [
"func",
"(",
"c",
"*",
"collectorImpl",
")",
"CollectUserEvent",
"(",
"record",
"*",
"collector",
".",
"UserRecord",
")",
"{",
"if",
"err",
":=",
"collector",
".",
"StatsUserHash",
"(",
"record",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"c",
".",
"ProcessedUsers",
"[",
"record",
".",
"ID",
"]",
";",
"!",
"ok",
"{",
"c",
".",
"Users",
"[",
"record",
".",
"ID",
"]",
"=",
"record",
"\n",
"c",
".",
"ProcessedUsers",
"[",
"record",
".",
"ID",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}"
] | // CollectUserEvent collects a new user event and adds it to a local cache. | [
"CollectUserEvent",
"collects",
"a",
"new",
"user",
"event",
"and",
"adds",
"it",
"to",
"a",
"local",
"cache",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go#L37-L50 |
7,067 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go | CollectPacketEvent | func (c *collectorImpl) CollectPacketEvent(report *collector.PacketReport) {
//We will leave this unimplemented
// trace event collection in done from the main enforcer
c.Lock()
defer c.Unlock()
zap.L().Debug("Collected Packet Event")
c.DatapathPacketReports = append(c.DatapathPacketReports, report)
} | go | func (c *collectorImpl) CollectPacketEvent(report *collector.PacketReport) {
//We will leave this unimplemented
// trace event collection in done from the main enforcer
c.Lock()
defer c.Unlock()
zap.L().Debug("Collected Packet Event")
c.DatapathPacketReports = append(c.DatapathPacketReports, report)
} | [
"func",
"(",
"c",
"*",
"collectorImpl",
")",
"CollectPacketEvent",
"(",
"report",
"*",
"collector",
".",
"PacketReport",
")",
"{",
"//We will leave this unimplemented",
"// trace event collection in done from the main enforcer",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"c",
".",
"DatapathPacketReports",
"=",
"append",
"(",
"c",
".",
"DatapathPacketReports",
",",
"report",
")",
"\n\n",
"}"
] | // CollectTraceEvent collect trace events | [
"CollectTraceEvent",
"collect",
"trace",
"events"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/collector_trireme.go#L59-L67 |
7,068 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/client.go | NewKubeClient | func NewKubeClient(kubeconfig string) (*kubernetes.Clientset, error) {
config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
if err != nil {
return nil, fmt.Errorf("Error Building config from Kubeconfig: %v", err)
}
return kubernetes.NewForConfig(config)
} | go | func NewKubeClient(kubeconfig string) (*kubernetes.Clientset, error) {
config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
if err != nil {
return nil, fmt.Errorf("Error Building config from Kubeconfig: %v", err)
}
return kubernetes.NewForConfig(config)
} | [
"func",
"NewKubeClient",
"(",
"kubeconfig",
"string",
")",
"(",
"*",
"kubernetes",
".",
"Clientset",
",",
"error",
")",
"{",
"config",
",",
"err",
":=",
"clientcmd",
".",
"BuildConfigFromFlags",
"(",
"\"",
"\"",
",",
"kubeconfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"kubernetes",
".",
"NewForConfig",
"(",
"config",
")",
"\n",
"}"
] | // NewKubeClient Generate and initialize a Kubernetes client based on the parameter kubeconfig | [
"NewKubeClient",
"Generate",
"and",
"initialize",
"a",
"Kubernetes",
"client",
"based",
"on",
"the",
"parameter",
"kubeconfig"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/client.go#L17-L24 |
7,069 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/client.go | CreateLocalPodController | func (m *KubernetesMonitor) CreateLocalPodController(namespace string,
addFunc func(addedApiStruct *api.Pod) error, deleteFunc func(deletedApiStruct *api.Pod) error, updateFunc func(oldApiStruct, updatedApiStruct *api.Pod) error) (kubecache.Store, kubecache.Controller) {
return CreateResourceController(m.kubeClient.CoreV1().RESTClient(), "pods", namespace, &api.Pod{}, m.localNodeSelector(),
func(addedApiStruct interface{}) {
if err := addFunc(addedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Add Pod", zap.Error(err))
}
},
func(deletedApiStruct interface{}) {
if err := deleteFunc(deletedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Delete Pod", zap.Error(err))
}
},
func(oldApiStruct, updatedApiStruct interface{}) {
if err := updateFunc(oldApiStruct.(*api.Pod), updatedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Update Pod", zap.Error(err))
}
})
} | go | func (m *KubernetesMonitor) CreateLocalPodController(namespace string,
addFunc func(addedApiStruct *api.Pod) error, deleteFunc func(deletedApiStruct *api.Pod) error, updateFunc func(oldApiStruct, updatedApiStruct *api.Pod) error) (kubecache.Store, kubecache.Controller) {
return CreateResourceController(m.kubeClient.CoreV1().RESTClient(), "pods", namespace, &api.Pod{}, m.localNodeSelector(),
func(addedApiStruct interface{}) {
if err := addFunc(addedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Add Pod", zap.Error(err))
}
},
func(deletedApiStruct interface{}) {
if err := deleteFunc(deletedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Delete Pod", zap.Error(err))
}
},
func(oldApiStruct, updatedApiStruct interface{}) {
if err := updateFunc(oldApiStruct.(*api.Pod), updatedApiStruct.(*api.Pod)); err != nil {
zap.L().Error("Error while handling Update Pod", zap.Error(err))
}
})
} | [
"func",
"(",
"m",
"*",
"KubernetesMonitor",
")",
"CreateLocalPodController",
"(",
"namespace",
"string",
",",
"addFunc",
"func",
"(",
"addedApiStruct",
"*",
"api",
".",
"Pod",
")",
"error",
",",
"deleteFunc",
"func",
"(",
"deletedApiStruct",
"*",
"api",
".",
"Pod",
")",
"error",
",",
"updateFunc",
"func",
"(",
"oldApiStruct",
",",
"updatedApiStruct",
"*",
"api",
".",
"Pod",
")",
"error",
")",
"(",
"kubecache",
".",
"Store",
",",
"kubecache",
".",
"Controller",
")",
"{",
"return",
"CreateResourceController",
"(",
"m",
".",
"kubeClient",
".",
"CoreV1",
"(",
")",
".",
"RESTClient",
"(",
")",
",",
"\"",
"\"",
",",
"namespace",
",",
"&",
"api",
".",
"Pod",
"{",
"}",
",",
"m",
".",
"localNodeSelector",
"(",
")",
",",
"func",
"(",
"addedApiStruct",
"interface",
"{",
"}",
")",
"{",
"if",
"err",
":=",
"addFunc",
"(",
"addedApiStruct",
".",
"(",
"*",
"api",
".",
"Pod",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
",",
"func",
"(",
"deletedApiStruct",
"interface",
"{",
"}",
")",
"{",
"if",
"err",
":=",
"deleteFunc",
"(",
"deletedApiStruct",
".",
"(",
"*",
"api",
".",
"Pod",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
",",
"func",
"(",
"oldApiStruct",
",",
"updatedApiStruct",
"interface",
"{",
"}",
")",
"{",
"if",
"err",
":=",
"updateFunc",
"(",
"oldApiStruct",
".",
"(",
"*",
"api",
".",
"Pod",
")",
",",
"updatedApiStruct",
".",
"(",
"*",
"api",
".",
"Pod",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // CreateLocalPodController creates a controller specifically for Pods. | [
"CreateLocalPodController",
"creates",
"a",
"controller",
"specifically",
"for",
"Pods",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/client.go#L43-L62 |
7,070 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/client.go | Pod | func (m *KubernetesMonitor) Pod(podName string, namespace string) (*api.Pod, error) {
targetPod, err := m.kubeClient.CoreV1().Pods(namespace).Get(podName, metav1.GetOptions{})
if err != nil {
return nil, fmt.Errorf("error getting Kubernetes labels & IP for pod %v : %v ", podName, err)
}
return targetPod, nil
} | go | func (m *KubernetesMonitor) Pod(podName string, namespace string) (*api.Pod, error) {
targetPod, err := m.kubeClient.CoreV1().Pods(namespace).Get(podName, metav1.GetOptions{})
if err != nil {
return nil, fmt.Errorf("error getting Kubernetes labels & IP for pod %v : %v ", podName, err)
}
return targetPod, nil
} | [
"func",
"(",
"m",
"*",
"KubernetesMonitor",
")",
"Pod",
"(",
"podName",
"string",
",",
"namespace",
"string",
")",
"(",
"*",
"api",
".",
"Pod",
",",
"error",
")",
"{",
"targetPod",
",",
"err",
":=",
"m",
".",
"kubeClient",
".",
"CoreV1",
"(",
")",
".",
"Pods",
"(",
"namespace",
")",
".",
"Get",
"(",
"podName",
",",
"metav1",
".",
"GetOptions",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"podName",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"targetPod",
",",
"nil",
"\n",
"}"
] | // Pod returns the full pod object. | [
"Pod",
"returns",
"the",
"full",
"pod",
"object",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/client.go#L71-L77 |
7,071 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go | DialMarkedWithContext | func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
return nil, nil
} | go | func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
return nil, nil
} | [
"func",
"DialMarkedWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
"string",
",",
"addr",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // DialMarkedWithContext dials a TCP connection and associates a mark. Propagates the context. | [
"DialMarkedWithContext",
"dials",
"a",
"TCP",
"connection",
"and",
"associates",
"a",
"mark",
".",
"Propagates",
"the",
"context",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go#L11-L13 |
7,072 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go | NewSocketListener | func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
return nil, nil
} | go | func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
return nil, nil
} | [
"func",
"NewSocketListener",
"(",
"ctx",
"context",
".",
"Context",
",",
"port",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // NewSocketListener creates a socket listener with marked connections. | [
"NewSocketListener",
"creates",
"a",
"socket",
"listener",
"with",
"marked",
"connections",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go#L16-L18 |
7,073 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go | GetOriginalDestination | func (p *ProxiedConnection) GetOriginalDestination() (net.IP, int) {
return p.originalIP, p.originalPort
} | go | func (p *ProxiedConnection) GetOriginalDestination() (net.IP, int) {
return p.originalIP, p.originalPort
} | [
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"GetOriginalDestination",
"(",
")",
"(",
"net",
".",
"IP",
",",
"int",
")",
"{",
"return",
"p",
".",
"originalIP",
",",
"p",
".",
"originalPort",
"\n",
"}"
] | // GetOriginalDestination sets the original destination of the connection. | [
"GetOriginalDestination",
"sets",
"the",
"original",
"destination",
"of",
"the",
"connection",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn_osx.go#L34-L36 |
7,074 | aporeto-inc/trireme-lib | monitor/remoteapi/server/uidlistener.go | Read | func (c UIDConnection) Read(b []byte) (n int, err error) {
return c.nc.Read(b)
} | go | func (c UIDConnection) Read(b []byte) (n int, err error) {
return c.nc.Read(b)
} | [
"func",
"(",
"c",
"UIDConnection",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"nc",
".",
"Read",
"(",
"b",
")",
"\n",
"}"
] | // Read implements the read interface of the connection. | [
"Read",
"implements",
"the",
"read",
"interface",
"of",
"the",
"connection",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/uidlistener.go#L19-L21 |
7,075 | aporeto-inc/trireme-lib | monitor/remoteapi/server/uidlistener.go | RemoteAddr | func (c UIDConnection) RemoteAddr() net.Addr {
uidAddr := &UIDAddr{
NetworkAddress: c.nc.RemoteAddr().Network(),
}
f, err := c.nc.File()
if err != nil {
uidAddr.Address = "NotAvailable"
}
defer f.Close() // nolint
cred, err := syscall.GetsockoptUcred(int(f.Fd()), syscall.SOL_SOCKET, syscall.SO_PEERCRED)
if err != nil {
uidAddr.Address = "NotAvailable"
}
uidAddr.Address = strconv.Itoa(int(cred.Uid)) + ":" + strconv.Itoa(int(cred.Gid)) + ":" + strconv.Itoa(int(cred.Pid))
return uidAddr
} | go | func (c UIDConnection) RemoteAddr() net.Addr {
uidAddr := &UIDAddr{
NetworkAddress: c.nc.RemoteAddr().Network(),
}
f, err := c.nc.File()
if err != nil {
uidAddr.Address = "NotAvailable"
}
defer f.Close() // nolint
cred, err := syscall.GetsockoptUcred(int(f.Fd()), syscall.SOL_SOCKET, syscall.SO_PEERCRED)
if err != nil {
uidAddr.Address = "NotAvailable"
}
uidAddr.Address = strconv.Itoa(int(cred.Uid)) + ":" + strconv.Itoa(int(cred.Gid)) + ":" + strconv.Itoa(int(cred.Pid))
return uidAddr
} | [
"func",
"(",
"c",
"UIDConnection",
")",
"RemoteAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"uidAddr",
":=",
"&",
"UIDAddr",
"{",
"NetworkAddress",
":",
"c",
".",
"nc",
".",
"RemoteAddr",
"(",
")",
".",
"Network",
"(",
")",
",",
"}",
"\n\n",
"f",
",",
"err",
":=",
"c",
".",
"nc",
".",
"File",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"uidAddr",
".",
"Address",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"// nolint",
"\n\n",
"cred",
",",
"err",
":=",
"syscall",
".",
"GetsockoptUcred",
"(",
"int",
"(",
"f",
".",
"Fd",
"(",
")",
")",
",",
"syscall",
".",
"SOL_SOCKET",
",",
"syscall",
".",
"SO_PEERCRED",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"uidAddr",
".",
"Address",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"uidAddr",
".",
"Address",
"=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"cred",
".",
"Uid",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"cred",
".",
"Gid",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"cred",
".",
"Pid",
")",
")",
"\n\n",
"return",
"uidAddr",
"\n\n",
"}"
] | // RemoteAddr implements the RemoteAddr interface of the connection.
// This is the main change where we actually use the FD of the unix
// socket to find the remote UID. | [
"RemoteAddr",
"implements",
"the",
"RemoteAddr",
"interface",
"of",
"the",
"connection",
".",
"This",
"is",
"the",
"main",
"change",
"where",
"we",
"actually",
"use",
"the",
"FD",
"of",
"the",
"unix",
"socket",
"to",
"find",
"the",
"remote",
"UID",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/uidlistener.go#L41-L62 |
7,076 | aporeto-inc/trireme-lib | monitor/remoteapi/server/uidlistener.go | SetDeadline | func (c UIDConnection) SetDeadline(t time.Time) error {
return c.nc.SetDeadline(t)
} | go | func (c UIDConnection) SetDeadline(t time.Time) error {
return c.nc.SetDeadline(t)
} | [
"func",
"(",
"c",
"UIDConnection",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"c",
".",
"nc",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetDeadline implements the SetDeadLine interface. | [
"SetDeadline",
"implements",
"the",
"SetDeadLine",
"interface",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/uidlistener.go#L65-L67 |
7,077 | aporeto-inc/trireme-lib | monitor/remoteapi/server/uidlistener.go | SetReadDeadline | func (c UIDConnection) SetReadDeadline(t time.Time) error {
return c.nc.SetReadDeadline(t)
} | go | func (c UIDConnection) SetReadDeadline(t time.Time) error {
return c.nc.SetReadDeadline(t)
} | [
"func",
"(",
"c",
"UIDConnection",
")",
"SetReadDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"c",
".",
"nc",
".",
"SetReadDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetReadDeadline implements the SetReadDeadling interface | [
"SetReadDeadline",
"implements",
"the",
"SetReadDeadling",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/uidlistener.go#L70-L72 |
7,078 | aporeto-inc/trireme-lib | monitor/remoteapi/server/uidlistener.go | SetWriteDeadline | func (c UIDConnection) SetWriteDeadline(t time.Time) error {
return c.nc.SetWriteDeadline(t)
} | go | func (c UIDConnection) SetWriteDeadline(t time.Time) error {
return c.nc.SetWriteDeadline(t)
} | [
"func",
"(",
"c",
"UIDConnection",
")",
"SetWriteDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"c",
".",
"nc",
".",
"SetWriteDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetWriteDeadline implements the SetWriteDeadline method of the interface. | [
"SetWriteDeadline",
"implements",
"the",
"SetWriteDeadline",
"method",
"of",
"the",
"interface",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/uidlistener.go#L75-L77 |
7,079 | aporeto-inc/trireme-lib | controller/internal/enforcer/acls/ports.go | newPortAction | func newPortAction(tcpport string, policy *policy.FlowPolicy) (*portAction, error) {
p := &portAction{}
if strings.Contains(tcpport, ":") {
parts := strings.Split(tcpport, ":")
if len(parts) != 2 {
return nil, fmt.Errorf("invalid port: %s", tcpport)
}
port, err := strconv.Atoi(parts[0])
if err != nil {
return nil, err
}
p.min = uint16(port)
port, err = strconv.Atoi(parts[1])
if err != nil {
return nil, err
}
p.max = uint16(port)
} else {
port, err := strconv.Atoi(tcpport)
if err != nil {
return nil, err
}
p.min = uint16(port)
p.max = p.min
}
if p.min > p.max {
return nil, errors.New("min port is greater than max port")
}
p.policy = policy
return p, nil
} | go | func newPortAction(tcpport string, policy *policy.FlowPolicy) (*portAction, error) {
p := &portAction{}
if strings.Contains(tcpport, ":") {
parts := strings.Split(tcpport, ":")
if len(parts) != 2 {
return nil, fmt.Errorf("invalid port: %s", tcpport)
}
port, err := strconv.Atoi(parts[0])
if err != nil {
return nil, err
}
p.min = uint16(port)
port, err = strconv.Atoi(parts[1])
if err != nil {
return nil, err
}
p.max = uint16(port)
} else {
port, err := strconv.Atoi(tcpport)
if err != nil {
return nil, err
}
p.min = uint16(port)
p.max = p.min
}
if p.min > p.max {
return nil, errors.New("min port is greater than max port")
}
p.policy = policy
return p, nil
} | [
"func",
"newPortAction",
"(",
"tcpport",
"string",
",",
"policy",
"*",
"policy",
".",
"FlowPolicy",
")",
"(",
"*",
"portAction",
",",
"error",
")",
"{",
"p",
":=",
"&",
"portAction",
"{",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"tcpport",
",",
"\"",
"\"",
")",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"tcpport",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tcpport",
")",
"\n",
"}",
"\n\n",
"port",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"p",
".",
"min",
"=",
"uint16",
"(",
"port",
")",
"\n\n",
"port",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"p",
".",
"max",
"=",
"uint16",
"(",
"port",
")",
"\n\n",
"}",
"else",
"{",
"port",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"tcpport",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"p",
".",
"min",
"=",
"uint16",
"(",
"port",
")",
"\n",
"p",
".",
"max",
"=",
"p",
".",
"min",
"\n",
"}",
"\n\n",
"if",
"p",
".",
"min",
">",
"p",
".",
"max",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"p",
".",
"policy",
"=",
"policy",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] | // newPortAction parses a port spec and creates the action | [
"newPortAction",
"parses",
"a",
"port",
"spec",
"and",
"creates",
"the",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/acls/ports.go#L26-L64 |
7,080 | aporeto-inc/trireme-lib | monitor/extractors/linux.go | DefaultHostMetadataExtractor | func DefaultHostMetadataExtractor(event *common.EventInfo) (*policy.PURuntime, error) {
runtimeTags := policy.NewTagStore()
for _, tag := range event.Tags {
parts := strings.SplitN(tag, "=", 2)
if len(parts) != 2 {
return nil, fmt.Errorf("invalid tag: %s", tag)
}
runtimeTags.AppendKeyValue("@usr:"+parts[0], parts[1])
}
options := &policy.OptionsType{
CgroupName: event.PUID,
CgroupMark: strconv.FormatUint(cgnetcls.MarkVal(), 10),
Services: event.Services,
}
runtimeIps := policy.ExtendedMap{"bridge": "0.0.0.0/0"}
return policy.NewPURuntime(event.Name, int(event.PID), "", runtimeTags, runtimeIps, event.PUType, options), nil
} | go | func DefaultHostMetadataExtractor(event *common.EventInfo) (*policy.PURuntime, error) {
runtimeTags := policy.NewTagStore()
for _, tag := range event.Tags {
parts := strings.SplitN(tag, "=", 2)
if len(parts) != 2 {
return nil, fmt.Errorf("invalid tag: %s", tag)
}
runtimeTags.AppendKeyValue("@usr:"+parts[0], parts[1])
}
options := &policy.OptionsType{
CgroupName: event.PUID,
CgroupMark: strconv.FormatUint(cgnetcls.MarkVal(), 10),
Services: event.Services,
}
runtimeIps := policy.ExtendedMap{"bridge": "0.0.0.0/0"}
return policy.NewPURuntime(event.Name, int(event.PID), "", runtimeTags, runtimeIps, event.PUType, options), nil
} | [
"func",
"DefaultHostMetadataExtractor",
"(",
"event",
"*",
"common",
".",
"EventInfo",
")",
"(",
"*",
"policy",
".",
"PURuntime",
",",
"error",
")",
"{",
"runtimeTags",
":=",
"policy",
".",
"NewTagStore",
"(",
")",
"\n\n",
"for",
"_",
",",
"tag",
":=",
"range",
"event",
".",
"Tags",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"tag",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n",
"runtimeTags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
"+",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"1",
"]",
")",
"\n",
"}",
"\n\n",
"options",
":=",
"&",
"policy",
".",
"OptionsType",
"{",
"CgroupName",
":",
"event",
".",
"PUID",
",",
"CgroupMark",
":",
"strconv",
".",
"FormatUint",
"(",
"cgnetcls",
".",
"MarkVal",
"(",
")",
",",
"10",
")",
",",
"Services",
":",
"event",
".",
"Services",
",",
"}",
"\n\n",
"runtimeIps",
":=",
"policy",
".",
"ExtendedMap",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
"\n\n",
"return",
"policy",
".",
"NewPURuntime",
"(",
"event",
".",
"Name",
",",
"int",
"(",
"event",
".",
"PID",
")",
",",
"\"",
"\"",
",",
"runtimeTags",
",",
"runtimeIps",
",",
"event",
".",
"PUType",
",",
"options",
")",
",",
"nil",
"\n",
"}"
] | // DefaultHostMetadataExtractor is a host specific metadata extractor | [
"DefaultHostMetadataExtractor",
"is",
"a",
"host",
"specific",
"metadata",
"extractor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/linux.go#L28-L49 |
7,081 | aporeto-inc/trireme-lib | monitor/extractors/linux.go | ProcessInfo | func ProcessInfo(pid int32) []string {
userdata := []string{}
p, err := process.NewProcess(pid)
if err != nil {
return userdata
}
uids, err := p.Uids()
if err != nil {
return userdata
}
groups, err := p.Gids()
if err != nil {
return userdata
}
username, err := p.Username()
if err != nil {
return userdata
}
for _, uid := range uids {
userdata = append(userdata, "uid:"+strconv.Itoa(int(uid)))
}
for _, gid := range groups {
userdata = append(userdata, "gid:"+strconv.Itoa(int(gid)))
}
userdata = append(userdata, "username:"+username)
userid, err := user.Lookup(username)
if err != nil {
return userdata
}
gids, err := userid.GroupIds()
if err != nil {
return userdata
}
for i := 0; i < len(gids); i++ {
userdata = append(userdata, "gids:"+gids[i])
group, err := user.LookupGroupId(gids[i])
if err != nil {
continue
}
userdata = append(userdata, "groups:"+group.Name)
}
return userdata
} | go | func ProcessInfo(pid int32) []string {
userdata := []string{}
p, err := process.NewProcess(pid)
if err != nil {
return userdata
}
uids, err := p.Uids()
if err != nil {
return userdata
}
groups, err := p.Gids()
if err != nil {
return userdata
}
username, err := p.Username()
if err != nil {
return userdata
}
for _, uid := range uids {
userdata = append(userdata, "uid:"+strconv.Itoa(int(uid)))
}
for _, gid := range groups {
userdata = append(userdata, "gid:"+strconv.Itoa(int(gid)))
}
userdata = append(userdata, "username:"+username)
userid, err := user.Lookup(username)
if err != nil {
return userdata
}
gids, err := userid.GroupIds()
if err != nil {
return userdata
}
for i := 0; i < len(gids); i++ {
userdata = append(userdata, "gids:"+gids[i])
group, err := user.LookupGroupId(gids[i])
if err != nil {
continue
}
userdata = append(userdata, "groups:"+group.Name)
}
return userdata
} | [
"func",
"ProcessInfo",
"(",
"pid",
"int32",
")",
"[",
"]",
"string",
"{",
"userdata",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"p",
",",
"err",
":=",
"process",
".",
"NewProcess",
"(",
"pid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"uids",
",",
"err",
":=",
"p",
".",
"Uids",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"groups",
",",
"err",
":=",
"p",
".",
"Gids",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"username",
",",
"err",
":=",
"p",
".",
"Username",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"uid",
":=",
"range",
"uids",
"{",
"userdata",
"=",
"append",
"(",
"userdata",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"uid",
")",
")",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"gid",
":=",
"range",
"groups",
"{",
"userdata",
"=",
"append",
"(",
"userdata",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"gid",
")",
")",
")",
"\n",
"}",
"\n\n",
"userdata",
"=",
"append",
"(",
"userdata",
",",
"\"",
"\"",
"+",
"username",
")",
"\n\n",
"userid",
",",
"err",
":=",
"user",
".",
"Lookup",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"gids",
",",
"err",
":=",
"userid",
".",
"GroupIds",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"userdata",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"gids",
")",
";",
"i",
"++",
"{",
"userdata",
"=",
"append",
"(",
"userdata",
",",
"\"",
"\"",
"+",
"gids",
"[",
"i",
"]",
")",
"\n",
"group",
",",
"err",
":=",
"user",
".",
"LookupGroupId",
"(",
"gids",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"userdata",
"=",
"append",
"(",
"userdata",
",",
"\"",
"\"",
"+",
"group",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"return",
"userdata",
"\n",
"}"
] | // ProcessInfo returns all metadata captured by a process | [
"ProcessInfo",
"returns",
"all",
"metadata",
"captured",
"by",
"a",
"process"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/linux.go#L108-L161 |
7,082 | aporeto-inc/trireme-lib | monitor/extractors/linux.go | libs | func libs(binpath string) []string {
f, err := elf.Open(binpath)
if err != nil {
return []string{}
}
libraries, _ := f.ImportedLibraries()
return libraries
} | go | func libs(binpath string) []string {
f, err := elf.Open(binpath)
if err != nil {
return []string{}
}
libraries, _ := f.ImportedLibraries()
return libraries
} | [
"func",
"libs",
"(",
"binpath",
"string",
")",
"[",
"]",
"string",
"{",
"f",
",",
"err",
":=",
"elf",
".",
"Open",
"(",
"binpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"libraries",
",",
"_",
":=",
"f",
".",
"ImportedLibraries",
"(",
")",
"\n",
"return",
"libraries",
"\n",
"}"
] | // libs returns the list of dynamic library dependencies of an executable | [
"libs",
"returns",
"the",
"list",
"of",
"dynamic",
"library",
"dependencies",
"of",
"an",
"executable"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/linux.go#L225-L232 |
7,083 | aporeto-inc/trireme-lib | monitor/extractors/linux.go | IsHostPU | func IsHostPU(runtime policy.RuntimeReader, mode constants.ModeType) bool {
if runtime == nil {
return false
}
if mode != constants.LocalServer {
return false
}
return runtime.PUType() == common.HostPU
} | go | func IsHostPU(runtime policy.RuntimeReader, mode constants.ModeType) bool {
if runtime == nil {
return false
}
if mode != constants.LocalServer {
return false
}
return runtime.PUType() == common.HostPU
} | [
"func",
"IsHostPU",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
",",
"mode",
"constants",
".",
"ModeType",
")",
"bool",
"{",
"if",
"runtime",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"mode",
"!=",
"constants",
".",
"LocalServer",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"runtime",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"HostPU",
"\n",
"}"
] | // IsHostPU returns true if puType stored by policy extensions is host PU | [
"IsHostPU",
"returns",
"true",
"if",
"puType",
"stored",
"by",
"policy",
"extensions",
"is",
"host",
"PU"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/linux.go#L266-L277 |
7,084 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/applicationproxy.go | NewAppProxy | func NewAppProxy(tp tokenaccessor.TokenAccessor, c collector.EventCollector, puFromID cache.DataStore, certificate *tls.Certificate, s secrets.Secrets) (*AppProxy, error) {
systemPool, err := x509.SystemCertPool()
if err != nil {
return nil, err
}
if ok := systemPool.AppendCertsFromPEM(s.PublicSecrets().CertAuthority()); !ok {
return nil, fmt.Errorf("error while adding provided CA")
}
return &AppProxy{
collector: c,
tokenaccessor: tp,
secrets: s,
puFromID: puFromID,
cert: certificate,
clients: cache.NewCache("clients"),
systemCAPool: systemPool,
registry: serviceregistry.NewServiceRegistry(),
}, nil
} | go | func NewAppProxy(tp tokenaccessor.TokenAccessor, c collector.EventCollector, puFromID cache.DataStore, certificate *tls.Certificate, s secrets.Secrets) (*AppProxy, error) {
systemPool, err := x509.SystemCertPool()
if err != nil {
return nil, err
}
if ok := systemPool.AppendCertsFromPEM(s.PublicSecrets().CertAuthority()); !ok {
return nil, fmt.Errorf("error while adding provided CA")
}
return &AppProxy{
collector: c,
tokenaccessor: tp,
secrets: s,
puFromID: puFromID,
cert: certificate,
clients: cache.NewCache("clients"),
systemCAPool: systemPool,
registry: serviceregistry.NewServiceRegistry(),
}, nil
} | [
"func",
"NewAppProxy",
"(",
"tp",
"tokenaccessor",
".",
"TokenAccessor",
",",
"c",
"collector",
".",
"EventCollector",
",",
"puFromID",
"cache",
".",
"DataStore",
",",
"certificate",
"*",
"tls",
".",
"Certificate",
",",
"s",
"secrets",
".",
"Secrets",
")",
"(",
"*",
"AppProxy",
",",
"error",
")",
"{",
"systemPool",
",",
"err",
":=",
"x509",
".",
"SystemCertPool",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"ok",
":=",
"systemPool",
".",
"AppendCertsFromPEM",
"(",
"s",
".",
"PublicSecrets",
"(",
")",
".",
"CertAuthority",
"(",
")",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"AppProxy",
"{",
"collector",
":",
"c",
",",
"tokenaccessor",
":",
"tp",
",",
"secrets",
":",
"s",
",",
"puFromID",
":",
"puFromID",
",",
"cert",
":",
"certificate",
",",
"clients",
":",
"cache",
".",
"NewCache",
"(",
"\"",
"\"",
")",
",",
"systemCAPool",
":",
"systemPool",
",",
"registry",
":",
"serviceregistry",
".",
"NewServiceRegistry",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewAppProxy creates a new instance of the application proxy. | [
"NewAppProxy",
"creates",
"a",
"new",
"instance",
"of",
"the",
"application",
"proxy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/applicationproxy.go#L61-L82 |
7,085 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/applicationproxy.go | Unenforce | func (p *AppProxy) Unenforce(ctx context.Context, puID string) error {
p.Lock()
defer p.Unlock()
// Remove pu from registry
if err := p.registry.Unregister(puID); err != nil {
return err
}
// Find the correct client.
c, err := p.clients.Get(puID)
if err != nil {
return fmt.Errorf("Unable to find client")
}
client := c.(*clientData)
// Shutdown all the servers and unregister listeners.
for t, server := range client.netserver {
if err := client.protomux.UnregisterListener(t); err != nil {
zap.L().Error("Unable to unregister client", zap.Int("type", int(t)), zap.Error(err))
}
if err := server.ShutDown(); err != nil {
zap.L().Debug("Unable to shutdown client server", zap.Error(err))
}
}
// Terminate the connection multiplexer.
client.protomux.Close()
// Remove the client from the cache.
return p.clients.Remove(puID)
} | go | func (p *AppProxy) Unenforce(ctx context.Context, puID string) error {
p.Lock()
defer p.Unlock()
// Remove pu from registry
if err := p.registry.Unregister(puID); err != nil {
return err
}
// Find the correct client.
c, err := p.clients.Get(puID)
if err != nil {
return fmt.Errorf("Unable to find client")
}
client := c.(*clientData)
// Shutdown all the servers and unregister listeners.
for t, server := range client.netserver {
if err := client.protomux.UnregisterListener(t); err != nil {
zap.L().Error("Unable to unregister client", zap.Int("type", int(t)), zap.Error(err))
}
if err := server.ShutDown(); err != nil {
zap.L().Debug("Unable to shutdown client server", zap.Error(err))
}
}
// Terminate the connection multiplexer.
client.protomux.Close()
// Remove the client from the cache.
return p.clients.Remove(puID)
} | [
"func",
"(",
"p",
"*",
"AppProxy",
")",
"Unenforce",
"(",
"ctx",
"context",
".",
"Context",
",",
"puID",
"string",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"// Remove pu from registry",
"if",
"err",
":=",
"p",
".",
"registry",
".",
"Unregister",
"(",
"puID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Find the correct client.",
"c",
",",
"err",
":=",
"p",
".",
"clients",
".",
"Get",
"(",
"puID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"client",
":=",
"c",
".",
"(",
"*",
"clientData",
")",
"\n\n",
"// Shutdown all the servers and unregister listeners.",
"for",
"t",
",",
"server",
":=",
"range",
"client",
".",
"netserver",
"{",
"if",
"err",
":=",
"client",
".",
"protomux",
".",
"UnregisterListener",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Int",
"(",
"\"",
"\"",
",",
"int",
"(",
"t",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"ShutDown",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Terminate the connection multiplexer.",
"client",
".",
"protomux",
".",
"Close",
"(",
")",
"\n\n",
"// Remove the client from the cache.",
"return",
"p",
".",
"clients",
".",
"Remove",
"(",
"puID",
")",
"\n",
"}"
] | // Unenforce implements enforcer.Enforcer interface. It will shutdown the app side
// of the proxy. | [
"Unenforce",
"implements",
"enforcer",
".",
"Enforcer",
"interface",
".",
"It",
"will",
"shutdown",
"the",
"app",
"side",
"of",
"the",
"proxy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/applicationproxy.go#L191-L222 |
7,086 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/applicationproxy.go | UpdateSecrets | func (p *AppProxy) UpdateSecrets(secret secrets.Secrets) error {
p.Lock()
defer p.Unlock()
p.secrets = secret
return nil
} | go | func (p *AppProxy) UpdateSecrets(secret secrets.Secrets) error {
p.Lock()
defer p.Unlock()
p.secrets = secret
return nil
} | [
"func",
"(",
"p",
"*",
"AppProxy",
")",
"UpdateSecrets",
"(",
"secret",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"secrets",
"=",
"secret",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpdateSecrets updates the secrets of running enforcers managed by trireme. Remote enforcers will
// get the secret updates with the next policy push. | [
"UpdateSecrets",
"updates",
"the",
"secrets",
"of",
"running",
"enforcers",
"managed",
"by",
"trireme",
".",
"Remote",
"enforcers",
"will",
"get",
"the",
"secret",
"updates",
"with",
"the",
"next",
"policy",
"push",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/applicationproxy.go#L231-L236 |
7,087 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/applicationproxy.go | registerAndRun | func (p *AppProxy) registerAndRun(ctx context.Context, puID string, ltype common.ListenerType, mux *protomux.MultiplexedListener, caPool *x509.CertPool, appproxy bool) (ServerInterface, error) {
var listener net.Listener
var err error
// Create a new sub-ordinate listerner and register it for the requested type.
listener, err = mux.RegisterListener(ltype)
if err != nil {
return nil, fmt.Errorf("Cannot register listener: %s", err)
}
// If the protocol is encrypted, wrapp it with TLS.
encrypted := false
if ltype == common.HTTPSNetwork {
encrypted = true
}
// Start the corresponding proxy
switch ltype {
case common.HTTPApplication, common.HTTPSApplication, common.HTTPNetwork, common.HTTPSNetwork:
c := httpproxy.NewHTTPProxy(p.collector, puID, caPool, appproxy, proxyMarkInt, p.secrets, p.registry)
return c, c.RunNetworkServer(ctx, listener, encrypted)
default:
c := tcp.NewTCPProxy(p.tokenaccessor, p.collector, puID, p.registry, p.cert, caPool)
return c, c.RunNetworkServer(ctx, listener, encrypted)
}
} | go | func (p *AppProxy) registerAndRun(ctx context.Context, puID string, ltype common.ListenerType, mux *protomux.MultiplexedListener, caPool *x509.CertPool, appproxy bool) (ServerInterface, error) {
var listener net.Listener
var err error
// Create a new sub-ordinate listerner and register it for the requested type.
listener, err = mux.RegisterListener(ltype)
if err != nil {
return nil, fmt.Errorf("Cannot register listener: %s", err)
}
// If the protocol is encrypted, wrapp it with TLS.
encrypted := false
if ltype == common.HTTPSNetwork {
encrypted = true
}
// Start the corresponding proxy
switch ltype {
case common.HTTPApplication, common.HTTPSApplication, common.HTTPNetwork, common.HTTPSNetwork:
c := httpproxy.NewHTTPProxy(p.collector, puID, caPool, appproxy, proxyMarkInt, p.secrets, p.registry)
return c, c.RunNetworkServer(ctx, listener, encrypted)
default:
c := tcp.NewTCPProxy(p.tokenaccessor, p.collector, puID, p.registry, p.cert, caPool)
return c, c.RunNetworkServer(ctx, listener, encrypted)
}
} | [
"func",
"(",
"p",
"*",
"AppProxy",
")",
"registerAndRun",
"(",
"ctx",
"context",
".",
"Context",
",",
"puID",
"string",
",",
"ltype",
"common",
".",
"ListenerType",
",",
"mux",
"*",
"protomux",
".",
"MultiplexedListener",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
"appproxy",
"bool",
")",
"(",
"ServerInterface",
",",
"error",
")",
"{",
"var",
"listener",
"net",
".",
"Listener",
"\n",
"var",
"err",
"error",
"\n\n",
"// Create a new sub-ordinate listerner and register it for the requested type.",
"listener",
",",
"err",
"=",
"mux",
".",
"RegisterListener",
"(",
"ltype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// If the protocol is encrypted, wrapp it with TLS.",
"encrypted",
":=",
"false",
"\n",
"if",
"ltype",
"==",
"common",
".",
"HTTPSNetwork",
"{",
"encrypted",
"=",
"true",
"\n",
"}",
"\n\n",
"// Start the corresponding proxy",
"switch",
"ltype",
"{",
"case",
"common",
".",
"HTTPApplication",
",",
"common",
".",
"HTTPSApplication",
",",
"common",
".",
"HTTPNetwork",
",",
"common",
".",
"HTTPSNetwork",
":",
"c",
":=",
"httpproxy",
".",
"NewHTTPProxy",
"(",
"p",
".",
"collector",
",",
"puID",
",",
"caPool",
",",
"appproxy",
",",
"proxyMarkInt",
",",
"p",
".",
"secrets",
",",
"p",
".",
"registry",
")",
"\n",
"return",
"c",
",",
"c",
".",
"RunNetworkServer",
"(",
"ctx",
",",
"listener",
",",
"encrypted",
")",
"\n",
"default",
":",
"c",
":=",
"tcp",
".",
"NewTCPProxy",
"(",
"p",
".",
"tokenaccessor",
",",
"p",
".",
"collector",
",",
"puID",
",",
"p",
".",
"registry",
",",
"p",
".",
"cert",
",",
"caPool",
")",
"\n",
"return",
"c",
",",
"c",
".",
"RunNetworkServer",
"(",
"ctx",
",",
"listener",
",",
"encrypted",
")",
"\n",
"}",
"\n",
"}"
] | // registerAndRun registers a new listener of the given type and runs the corresponding server | [
"registerAndRun",
"registers",
"a",
"new",
"listener",
"of",
"the",
"given",
"type",
"and",
"runs",
"the",
"corresponding",
"server"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/applicationproxy.go#L239-L264 |
7,088 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/applicationproxy.go | processCertificateUpdates | func (p *AppProxy) processCertificateUpdates(puInfo *policy.PUInfo, client *clientData, caPool *x509.CertPool) (bool, error) {
// If there are certificates provided, we will need to update them for the
// services. If the certificates are nil, we ignore them.
certPEM, keyPEM, caPEM := puInfo.Policy.ServiceCertificates()
if certPEM == "" || keyPEM == "" {
return false, nil
}
// Process any updates on the cert pool
if caPEM != "" {
if !caPool.AppendCertsFromPEM([]byte(caPEM)) {
zap.L().Warn("Failed to add Services CA")
}
}
// Create the TLS certificate
tlsCert, err := tls.X509KeyPair([]byte(certPEM), []byte(keyPEM))
if err != nil {
return false, fmt.Errorf("Invalid certificates: %s", err)
}
for _, server := range client.netserver {
server.UpdateSecrets(&tlsCert, caPool, p.secrets, certPEM, keyPEM)
}
return true, nil
} | go | func (p *AppProxy) processCertificateUpdates(puInfo *policy.PUInfo, client *clientData, caPool *x509.CertPool) (bool, error) {
// If there are certificates provided, we will need to update them for the
// services. If the certificates are nil, we ignore them.
certPEM, keyPEM, caPEM := puInfo.Policy.ServiceCertificates()
if certPEM == "" || keyPEM == "" {
return false, nil
}
// Process any updates on the cert pool
if caPEM != "" {
if !caPool.AppendCertsFromPEM([]byte(caPEM)) {
zap.L().Warn("Failed to add Services CA")
}
}
// Create the TLS certificate
tlsCert, err := tls.X509KeyPair([]byte(certPEM), []byte(keyPEM))
if err != nil {
return false, fmt.Errorf("Invalid certificates: %s", err)
}
for _, server := range client.netserver {
server.UpdateSecrets(&tlsCert, caPool, p.secrets, certPEM, keyPEM)
}
return true, nil
} | [
"func",
"(",
"p",
"*",
"AppProxy",
")",
"processCertificateUpdates",
"(",
"puInfo",
"*",
"policy",
".",
"PUInfo",
",",
"client",
"*",
"clientData",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
")",
"(",
"bool",
",",
"error",
")",
"{",
"// If there are certificates provided, we will need to update them for the",
"// services. If the certificates are nil, we ignore them.",
"certPEM",
",",
"keyPEM",
",",
"caPEM",
":=",
"puInfo",
".",
"Policy",
".",
"ServiceCertificates",
"(",
")",
"\n",
"if",
"certPEM",
"==",
"\"",
"\"",
"||",
"keyPEM",
"==",
"\"",
"\"",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"// Process any updates on the cert pool",
"if",
"caPEM",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"caPool",
".",
"AppendCertsFromPEM",
"(",
"[",
"]",
"byte",
"(",
"caPEM",
")",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Create the TLS certificate",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"[",
"]",
"byte",
"(",
"certPEM",
")",
",",
"[",
"]",
"byte",
"(",
"keyPEM",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"server",
":=",
"range",
"client",
".",
"netserver",
"{",
"server",
".",
"UpdateSecrets",
"(",
"&",
"tlsCert",
",",
"caPool",
",",
"p",
".",
"secrets",
",",
"certPEM",
",",
"keyPEM",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // processCertificateUpdates processes the certificate information and updates
// the servers. | [
"processCertificateUpdates",
"processes",
"the",
"certificate",
"information",
"and",
"updates",
"the",
"servers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/applicationproxy.go#L273-L299 |
7,089 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/nfq_linux.go | startNetworkInterceptor | func (d *Datapath) startNetworkInterceptor(ctx context.Context) {
var err error
nfq := make([]nfqueue.Verdict, d.filterQueue.GetNumNetworkQueues())
for i := uint16(0); i < d.filterQueue.GetNumNetworkQueues(); i++ {
// Initialize all the queues
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetNetworkQueueStart()+i, d.filterQueue.GetNetworkQueueSize(), nfqueue.NfDefaultPacketSize, networkCallback, errorCallback, d)
if err != nil {
for retry := 0; retry < 5 && err != nil; retry++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetNetworkQueueStart()+i, d.filterQueue.GetNetworkQueueSize(), nfqueue.NfDefaultPacketSize, networkCallback, errorCallback, d)
<-time.After(3 * time.Second)
}
if err != nil {
zap.L().Fatal("Unable to initialize netfilter queue", zap.Error(err))
}
}
}
} | go | func (d *Datapath) startNetworkInterceptor(ctx context.Context) {
var err error
nfq := make([]nfqueue.Verdict, d.filterQueue.GetNumNetworkQueues())
for i := uint16(0); i < d.filterQueue.GetNumNetworkQueues(); i++ {
// Initialize all the queues
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetNetworkQueueStart()+i, d.filterQueue.GetNetworkQueueSize(), nfqueue.NfDefaultPacketSize, networkCallback, errorCallback, d)
if err != nil {
for retry := 0; retry < 5 && err != nil; retry++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetNetworkQueueStart()+i, d.filterQueue.GetNetworkQueueSize(), nfqueue.NfDefaultPacketSize, networkCallback, errorCallback, d)
<-time.After(3 * time.Second)
}
if err != nil {
zap.L().Fatal("Unable to initialize netfilter queue", zap.Error(err))
}
}
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"startNetworkInterceptor",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"var",
"err",
"error",
"\n\n",
"nfq",
":=",
"make",
"(",
"[",
"]",
"nfqueue",
".",
"Verdict",
",",
"d",
".",
"filterQueue",
".",
"GetNumNetworkQueues",
"(",
")",
")",
"\n\n",
"for",
"i",
":=",
"uint16",
"(",
"0",
")",
";",
"i",
"<",
"d",
".",
"filterQueue",
".",
"GetNumNetworkQueues",
"(",
")",
";",
"i",
"++",
"{",
"// Initialize all the queues",
"nfq",
"[",
"i",
"]",
",",
"err",
"=",
"nfqueue",
".",
"CreateAndStartNfQueue",
"(",
"ctx",
",",
"d",
".",
"filterQueue",
".",
"GetNetworkQueueStart",
"(",
")",
"+",
"i",
",",
"d",
".",
"filterQueue",
".",
"GetNetworkQueueSize",
"(",
")",
",",
"nfqueue",
".",
"NfDefaultPacketSize",
",",
"networkCallback",
",",
"errorCallback",
",",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"for",
"retry",
":=",
"0",
";",
"retry",
"<",
"5",
"&&",
"err",
"!=",
"nil",
";",
"retry",
"++",
"{",
"nfq",
"[",
"i",
"]",
",",
"err",
"=",
"nfqueue",
".",
"CreateAndStartNfQueue",
"(",
"ctx",
",",
"d",
".",
"filterQueue",
".",
"GetNetworkQueueStart",
"(",
")",
"+",
"i",
",",
"d",
".",
"filterQueue",
".",
"GetNetworkQueueSize",
"(",
")",
",",
"nfqueue",
".",
"NfDefaultPacketSize",
",",
"networkCallback",
",",
"errorCallback",
",",
"d",
")",
"\n",
"<-",
"time",
".",
"After",
"(",
"3",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // startNetworkInterceptor will the process that processes packets from the network
// Still has one more copy than needed. Can be improved. | [
"startNetworkInterceptor",
"will",
"the",
"process",
"that",
"processes",
"packets",
"from",
"the",
"network",
"Still",
"has",
"one",
"more",
"copy",
"than",
"needed",
".",
"Can",
"be",
"improved",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/nfq_linux.go#L33-L51 |
7,090 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/nfq_linux.go | startApplicationInterceptor | func (d *Datapath) startApplicationInterceptor(ctx context.Context) {
var err error
nfq := make([]nfqueue.Verdict, d.filterQueue.GetNumApplicationQueues())
for i := uint16(0); i < d.filterQueue.GetNumApplicationQueues(); i++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetApplicationQueueStart()+i, d.filterQueue.GetApplicationQueueSize(), nfqueue.NfDefaultPacketSize, appCallBack, errorCallback, d)
if err != nil {
for retry := 0; retry < 5 && err != nil; retry++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetApplicationQueueStart()+i, d.filterQueue.GetApplicationQueueSize(), nfqueue.NfDefaultPacketSize, appCallBack, errorCallback, d)
<-time.After(3 * time.Second)
}
if err != nil {
zap.L().Fatal("Unable to initialize netfilter queue", zap.Int("QueueNum", int(d.filterQueue.GetNetworkQueueStart()+i)), zap.Error(err))
}
}
}
} | go | func (d *Datapath) startApplicationInterceptor(ctx context.Context) {
var err error
nfq := make([]nfqueue.Verdict, d.filterQueue.GetNumApplicationQueues())
for i := uint16(0); i < d.filterQueue.GetNumApplicationQueues(); i++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetApplicationQueueStart()+i, d.filterQueue.GetApplicationQueueSize(), nfqueue.NfDefaultPacketSize, appCallBack, errorCallback, d)
if err != nil {
for retry := 0; retry < 5 && err != nil; retry++ {
nfq[i], err = nfqueue.CreateAndStartNfQueue(ctx, d.filterQueue.GetApplicationQueueStart()+i, d.filterQueue.GetApplicationQueueSize(), nfqueue.NfDefaultPacketSize, appCallBack, errorCallback, d)
<-time.After(3 * time.Second)
}
if err != nil {
zap.L().Fatal("Unable to initialize netfilter queue", zap.Int("QueueNum", int(d.filterQueue.GetNetworkQueueStart()+i)), zap.Error(err))
}
}
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"startApplicationInterceptor",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"var",
"err",
"error",
"\n\n",
"nfq",
":=",
"make",
"(",
"[",
"]",
"nfqueue",
".",
"Verdict",
",",
"d",
".",
"filterQueue",
".",
"GetNumApplicationQueues",
"(",
")",
")",
"\n\n",
"for",
"i",
":=",
"uint16",
"(",
"0",
")",
";",
"i",
"<",
"d",
".",
"filterQueue",
".",
"GetNumApplicationQueues",
"(",
")",
";",
"i",
"++",
"{",
"nfq",
"[",
"i",
"]",
",",
"err",
"=",
"nfqueue",
".",
"CreateAndStartNfQueue",
"(",
"ctx",
",",
"d",
".",
"filterQueue",
".",
"GetApplicationQueueStart",
"(",
")",
"+",
"i",
",",
"d",
".",
"filterQueue",
".",
"GetApplicationQueueSize",
"(",
")",
",",
"nfqueue",
".",
"NfDefaultPacketSize",
",",
"appCallBack",
",",
"errorCallback",
",",
"d",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"for",
"retry",
":=",
"0",
";",
"retry",
"<",
"5",
"&&",
"err",
"!=",
"nil",
";",
"retry",
"++",
"{",
"nfq",
"[",
"i",
"]",
",",
"err",
"=",
"nfqueue",
".",
"CreateAndStartNfQueue",
"(",
"ctx",
",",
"d",
".",
"filterQueue",
".",
"GetApplicationQueueStart",
"(",
")",
"+",
"i",
",",
"d",
".",
"filterQueue",
".",
"GetApplicationQueueSize",
"(",
")",
",",
"nfqueue",
".",
"NfDefaultPacketSize",
",",
"appCallBack",
",",
"errorCallback",
",",
"d",
")",
"\n",
"<-",
"time",
".",
"After",
"(",
"3",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"zap",
".",
"Int",
"(",
"\"",
"\"",
",",
"int",
"(",
"d",
".",
"filterQueue",
".",
"GetNetworkQueueStart",
"(",
")",
"+",
"i",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"}",
"\n",
"}"
] | // startApplicationInterceptor will create a interceptor that processes
// packets originated from a local application | [
"startApplicationInterceptor",
"will",
"create",
"a",
"interceptor",
"that",
"processes",
"packets",
"originated",
"from",
"a",
"local",
"application"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/nfq_linux.go#L55-L74 |
7,091 | aporeto-inc/trireme-lib | policy/runtime.go | NewPURuntime | func NewPURuntime(name string, pid int, nsPath string, tags *TagStore, ips ExtendedMap, puType common.PUType, options *OptionsType) *PURuntime {
if tags == nil {
tags = NewTagStore()
}
if ips == nil {
ips = ExtendedMap{}
}
if options == nil {
options = &OptionsType{}
}
return &PURuntime{
puType: puType,
tags: tags,
ips: ips,
options: options,
pid: pid,
nsPath: nsPath,
name: name,
}
} | go | func NewPURuntime(name string, pid int, nsPath string, tags *TagStore, ips ExtendedMap, puType common.PUType, options *OptionsType) *PURuntime {
if tags == nil {
tags = NewTagStore()
}
if ips == nil {
ips = ExtendedMap{}
}
if options == nil {
options = &OptionsType{}
}
return &PURuntime{
puType: puType,
tags: tags,
ips: ips,
options: options,
pid: pid,
nsPath: nsPath,
name: name,
}
} | [
"func",
"NewPURuntime",
"(",
"name",
"string",
",",
"pid",
"int",
",",
"nsPath",
"string",
",",
"tags",
"*",
"TagStore",
",",
"ips",
"ExtendedMap",
",",
"puType",
"common",
".",
"PUType",
",",
"options",
"*",
"OptionsType",
")",
"*",
"PURuntime",
"{",
"if",
"tags",
"==",
"nil",
"{",
"tags",
"=",
"NewTagStore",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"ips",
"==",
"nil",
"{",
"ips",
"=",
"ExtendedMap",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"options",
"==",
"nil",
"{",
"options",
"=",
"&",
"OptionsType",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"PURuntime",
"{",
"puType",
":",
"puType",
",",
"tags",
":",
"tags",
",",
"ips",
":",
"ips",
",",
"options",
":",
"options",
",",
"pid",
":",
"pid",
",",
"nsPath",
":",
"nsPath",
",",
"name",
":",
"name",
",",
"}",
"\n",
"}"
] | // NewPURuntime Generate a new RuntimeInfo | [
"NewPURuntime",
"Generate",
"a",
"new",
"RuntimeInfo"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L50-L73 |
7,092 | aporeto-inc/trireme-lib | policy/runtime.go | MarshalJSON | func (r *PURuntime) MarshalJSON() ([]byte, error) {
return json.Marshal(&PURuntimeJSON{
PUType: r.puType,
Pid: r.pid,
NSPath: r.nsPath,
Name: r.name,
IPAddresses: r.ips,
Tags: r.tags,
Options: r.options,
})
} | go | func (r *PURuntime) MarshalJSON() ([]byte, error) {
return json.Marshal(&PURuntimeJSON{
PUType: r.puType,
Pid: r.pid,
NSPath: r.nsPath,
Name: r.name,
IPAddresses: r.ips,
Tags: r.tags,
Options: r.options,
})
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"&",
"PURuntimeJSON",
"{",
"PUType",
":",
"r",
".",
"puType",
",",
"Pid",
":",
"r",
".",
"pid",
",",
"NSPath",
":",
"r",
".",
"nsPath",
",",
"Name",
":",
"r",
".",
"name",
",",
"IPAddresses",
":",
"r",
".",
"ips",
",",
"Tags",
":",
"r",
".",
"tags",
",",
"Options",
":",
"r",
".",
"options",
",",
"}",
")",
"\n",
"}"
] | // MarshalJSON Marshals this struct. | [
"MarshalJSON",
"Marshals",
"this",
"struct",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L90-L100 |
7,093 | aporeto-inc/trireme-lib | policy/runtime.go | UnmarshalJSON | func (r *PURuntime) UnmarshalJSON(param []byte) error {
a := &PURuntimeJSON{}
if err := json.Unmarshal(param, &a); err != nil {
return err
}
r.pid = a.Pid
r.nsPath = a.NSPath
r.name = a.Name
r.ips = a.IPAddresses
r.tags = a.Tags
r.options = a.Options
r.puType = a.PUType
return nil
} | go | func (r *PURuntime) UnmarshalJSON(param []byte) error {
a := &PURuntimeJSON{}
if err := json.Unmarshal(param, &a); err != nil {
return err
}
r.pid = a.Pid
r.nsPath = a.NSPath
r.name = a.Name
r.ips = a.IPAddresses
r.tags = a.Tags
r.options = a.Options
r.puType = a.PUType
return nil
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"UnmarshalJSON",
"(",
"param",
"[",
"]",
"byte",
")",
"error",
"{",
"a",
":=",
"&",
"PURuntimeJSON",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"param",
",",
"&",
"a",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"r",
".",
"pid",
"=",
"a",
".",
"Pid",
"\n",
"r",
".",
"nsPath",
"=",
"a",
".",
"NSPath",
"\n",
"r",
".",
"name",
"=",
"a",
".",
"Name",
"\n",
"r",
".",
"ips",
"=",
"a",
".",
"IPAddresses",
"\n",
"r",
".",
"tags",
"=",
"a",
".",
"Tags",
"\n",
"r",
".",
"options",
"=",
"a",
".",
"Options",
"\n",
"r",
".",
"puType",
"=",
"a",
".",
"PUType",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON Unmarshals this struct. | [
"UnmarshalJSON",
"Unmarshals",
"this",
"struct",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L103-L116 |
7,094 | aporeto-inc/trireme-lib | policy/runtime.go | Pid | func (r *PURuntime) Pid() int {
r.Lock()
defer r.Unlock()
return r.pid
} | go | func (r *PURuntime) Pid() int {
r.Lock()
defer r.Unlock()
return r.pid
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"Pid",
"(",
")",
"int",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"r",
".",
"pid",
"\n",
"}"
] | // Pid returns the PID | [
"Pid",
"returns",
"the",
"PID"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L119-L124 |
7,095 | aporeto-inc/trireme-lib | policy/runtime.go | SetPid | func (r *PURuntime) SetPid(pid int) {
r.Lock()
defer r.Unlock()
r.pid = pid
} | go | func (r *PURuntime) SetPid(pid int) {
r.Lock()
defer r.Unlock()
r.pid = pid
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"SetPid",
"(",
"pid",
"int",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"r",
".",
"pid",
"=",
"pid",
"\n",
"}"
] | // SetPid sets the PID | [
"SetPid",
"sets",
"the",
"PID"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L127-L132 |
7,096 | aporeto-inc/trireme-lib | policy/runtime.go | NSPath | func (r *PURuntime) NSPath() string {
r.Lock()
defer r.Unlock()
return r.nsPath
} | go | func (r *PURuntime) NSPath() string {
r.Lock()
defer r.Unlock()
return r.nsPath
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"NSPath",
"(",
")",
"string",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"r",
".",
"nsPath",
"\n",
"}"
] | // NSPath returns the NSPath | [
"NSPath",
"returns",
"the",
"NSPath"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L135-L140 |
7,097 | aporeto-inc/trireme-lib | policy/runtime.go | SetNSPath | func (r *PURuntime) SetNSPath(nsPath string) {
r.Lock()
defer r.Unlock()
r.nsPath = nsPath
} | go | func (r *PURuntime) SetNSPath(nsPath string) {
r.Lock()
defer r.Unlock()
r.nsPath = nsPath
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"SetNSPath",
"(",
"nsPath",
"string",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"r",
".",
"nsPath",
"=",
"nsPath",
"\n",
"}"
] | // SetNSPath sets the NSPath | [
"SetNSPath",
"sets",
"the",
"NSPath"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L143-L148 |
7,098 | aporeto-inc/trireme-lib | policy/runtime.go | SetOptions | func (r *PURuntime) SetOptions(options OptionsType) {
r.Lock()
defer r.Unlock()
r.options = &options
} | go | func (r *PURuntime) SetOptions(options OptionsType) {
r.Lock()
defer r.Unlock()
r.options = &options
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"SetOptions",
"(",
"options",
"OptionsType",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"r",
".",
"options",
"=",
"&",
"options",
"\n",
"}"
] | // SetOptions sets the Options | [
"SetOptions",
"sets",
"the",
"Options"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L159-L164 |
7,099 | aporeto-inc/trireme-lib | policy/runtime.go | Name | func (r *PURuntime) Name() string {
r.Lock()
defer r.Unlock()
return r.name
} | go | func (r *PURuntime) Name() string {
r.Lock()
defer r.Unlock()
return r.name
} | [
"func",
"(",
"r",
"*",
"PURuntime",
")",
"Name",
"(",
")",
"string",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"r",
".",
"name",
"\n",
"}"
] | // Name returns the PID | [
"Name",
"returns",
"the",
"PID"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/runtime.go#L167-L172 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.