id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
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",
... | // 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",
":=",
... | // 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",
"... | // 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 firs... | // 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... | 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",
".",
"ExposedS... | // 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",
... | // 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",
"==",
"ni... | // 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",
")",
"... | // 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",
... | // 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",
"(",
"... | // 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",
".",
"... | // 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"... | // 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",
"(",
"\"",
"\"",
... | // 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"... | 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... | // 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",
"conta... | //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",
"... | // 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"... | // 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",
"... | // 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... | // 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",
... | 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",
... | // 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",
".",
"Strin... | // 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",
... | // 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",
":=",
"... | // 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",
... | // 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",
"]... | // 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",
".",
"... | // 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",
... | // 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",
"(",
")"... | // 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"... | // 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",
"_",
",",
"... | // 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",
"}",
... | // 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"... | // 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",
",",
"\"",
"\"",
",",
"re... | // 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",
... | // 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",
",",
... | // 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",
",... | // 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",
"(",
")",
... | // 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"... | // 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",
",",
"p... | // 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",
"!=",
... | // 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",
"=... | // 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",
"... | // 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",
"!=... | // 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",
... | 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",
",",
"... | //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",
",",
"cgro... | // 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",
",",
"c... | //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",
")",
")",
... | // 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",
"a... | 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",
",",
... | //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",
".",
... | // 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",
",",
"pat... | // 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... | // 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",
"{... | //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",
",",
"// token... | // 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",
".",
... | // 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",
... | // 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",
"(",
"\"",
"\"",
")",
... | // 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",
"{",
... | // 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",
".",... | // 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"... | // 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",
"... | // 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",
"{... | // 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 le... | // 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",
"(",... | // 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"... | // 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",
... | // 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",
".",
... | // 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",
"(",
")",
... | // 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",
",",... | // 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",
","... | // 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",
":=",
"... | // 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",
... | // 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",
"... | // 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",
... | // 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",
")",
"... | // 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",
... | // 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",... | // 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",
".",
... | // 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 cert... | // 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",
".",
"GetNum... | // 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",
".",
"Ge... | // 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",
"{",
"i... | // 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"... | // 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... | // 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.