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,300 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | RemoteCall | func (r *RPCWrapper) RemoteCall(contextID string, methodName string, req *Request, resp *Response) error {
rpcClient, err := r.GetRPCClient(contextID)
if err != nil {
return err
}
digest := hmac.New(sha256.New, []byte(rpcClient.Secret))
hash, err := payloadHash(req.Payload)
if err != nil {
return err
}
if _, err := digest.Write(hash); err != nil {
return err
}
req.HashAuth = digest.Sum(nil)
return rpcClient.Client.Call(methodName, req, resp)
} | go | func (r *RPCWrapper) RemoteCall(contextID string, methodName string, req *Request, resp *Response) error {
rpcClient, err := r.GetRPCClient(contextID)
if err != nil {
return err
}
digest := hmac.New(sha256.New, []byte(rpcClient.Secret))
hash, err := payloadHash(req.Payload)
if err != nil {
return err
}
if _, err := digest.Write(hash); err != nil {
return err
}
req.HashAuth = digest.Sum(nil)
return rpcClient.Client.Call(methodName, req, resp)
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"RemoteCall",
"(",
"contextID",
"string",
",",
"methodName",
"string",
",",
"req",
"*",
"Request",
",",
"resp",
"*",
"Response",
")",
"error",
"{",
"rpcClient",
",",
"err",
":=",
"r",
".",
"GetRPCClient",
"(",
... | // RemoteCall is a wrapper around rpc.Call and also ensure message integrity by adding a hmac | [
"RemoteCall",
"is",
"a",
"wrapper",
"around",
"rpc",
".",
"Call",
"and",
"also",
"ensure",
"message",
"integrity",
"by",
"adding",
"a",
"hmac"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L99-L119 |
7,301 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | CheckValidity | func (r *RPCWrapper) CheckValidity(req *Request, secret string) bool {
digest := hmac.New(sha256.New, []byte(secret))
hash, err := payloadHash(req.Payload)
if err != nil {
return false
}
if _, err := digest.Write(hash); err != nil {
return false
}
return hmac.Equal(req.HashAuth, digest.Sum(nil))
} | go | func (r *RPCWrapper) CheckValidity(req *Request, secret string) bool {
digest := hmac.New(sha256.New, []byte(secret))
hash, err := payloadHash(req.Payload)
if err != nil {
return false
}
if _, err := digest.Write(hash); err != nil {
return false
}
return hmac.Equal(req.HashAuth, digest.Sum(nil))
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"CheckValidity",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
"{",
"digest",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"[",
"]",
"byte",
"(",
"secret",
")",
")",
"\n\n",... | // CheckValidity checks if the received message is valid | [
"CheckValidity",
"checks",
"if",
"the",
"received",
"message",
"is",
"valid"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L122-L136 |
7,302 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | StartServer | func (r *RPCWrapper) StartServer(ctx context.Context, protocol string, path string, handler interface{}) error {
if len(path) == 0 {
zap.L().Fatal("Sock param not passed in environment")
}
// Register RPC Type
RegisterTypes()
// Register handlers
if err := rpc.Register(handler); err != nil {
return err
}
rpc.HandleHTTP()
// removing old path in case it exists already - error if we can't remove it
if _, err := os.Stat(path); err == nil {
zap.L().Debug("Socket path already exists: removing", zap.String("path", path))
if rerr := os.Remove(path); rerr != nil {
return fmt.Errorf("unable to delete existing socket path %s: %s", path, rerr)
}
}
// Get listener
listen, err := net.Listen(protocol, path)
if err != nil {
return err
}
go http.Serve(listen, nil) // nolint
<-ctx.Done()
if merr := listen.Close(); merr != nil {
zap.L().Warn("Connection already closed", zap.Error(merr))
}
_, err = os.Stat(path)
if !os.IsNotExist(err) {
if err := os.Remove(path); err != nil {
zap.L().Warn("failed to remove old path", zap.Error(err))
}
}
return nil
} | go | func (r *RPCWrapper) StartServer(ctx context.Context, protocol string, path string, handler interface{}) error {
if len(path) == 0 {
zap.L().Fatal("Sock param not passed in environment")
}
// Register RPC Type
RegisterTypes()
// Register handlers
if err := rpc.Register(handler); err != nil {
return err
}
rpc.HandleHTTP()
// removing old path in case it exists already - error if we can't remove it
if _, err := os.Stat(path); err == nil {
zap.L().Debug("Socket path already exists: removing", zap.String("path", path))
if rerr := os.Remove(path); rerr != nil {
return fmt.Errorf("unable to delete existing socket path %s: %s", path, rerr)
}
}
// Get listener
listen, err := net.Listen(protocol, path)
if err != nil {
return err
}
go http.Serve(listen, nil) // nolint
<-ctx.Done()
if merr := listen.Close(); merr != nil {
zap.L().Warn("Connection already closed", zap.Error(merr))
}
_, err = os.Stat(path)
if !os.IsNotExist(err) {
if err := os.Remove(path); err != nil {
zap.L().Warn("failed to remove old path", zap.Error(err))
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"StartServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"protocol",
"string",
",",
"path",
"string",
",",
"handler",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"len",
"(",
"path",
")",
"==",
"0",
"{",... | // StartServer Starts a server and waits for new connections this function never returns | [
"StartServer",
"Starts",
"a",
"server",
"and",
"waits",
"for",
"new",
"connections",
"this",
"function",
"never",
"returns"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L145-L192 |
7,303 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | DestroyRPCClient | func (r *RPCWrapper) DestroyRPCClient(contextID string) {
r.Lock()
defer r.Unlock()
rpcHdl, err := r.rpcClientMap.Get(contextID)
if err != nil {
return
}
if err = rpcHdl.(*RPCHdl).Client.Close(); err != nil {
zap.L().Warn("Failed to close channel",
zap.String("contextID", contextID),
zap.Error(err),
)
}
if err = os.Remove(rpcHdl.(*RPCHdl).Channel); err != nil {
zap.L().Debug("Failed to remove channel - already closed",
zap.String("contextID", contextID),
zap.Error(err),
)
}
if err = r.rpcClientMap.Remove(contextID); err != nil {
zap.L().Warn("Failed to remove item from cache",
zap.String("contextID", contextID),
zap.Error(err),
)
}
} | go | func (r *RPCWrapper) DestroyRPCClient(contextID string) {
r.Lock()
defer r.Unlock()
rpcHdl, err := r.rpcClientMap.Get(contextID)
if err != nil {
return
}
if err = rpcHdl.(*RPCHdl).Client.Close(); err != nil {
zap.L().Warn("Failed to close channel",
zap.String("contextID", contextID),
zap.Error(err),
)
}
if err = os.Remove(rpcHdl.(*RPCHdl).Channel); err != nil {
zap.L().Debug("Failed to remove channel - already closed",
zap.String("contextID", contextID),
zap.Error(err),
)
}
if err = r.rpcClientMap.Remove(contextID); err != nil {
zap.L().Warn("Failed to remove item from cache",
zap.String("contextID", contextID),
zap.Error(err),
)
}
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"DestroyRPCClient",
"(",
"contextID",
"string",
")",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"rpcHdl",
",",
"err",
":=",
"r",
".",
"rpcClientMap",
".",
"Get",
"... | // DestroyRPCClient calls close on the rpc and cleans up the connection | [
"DestroyRPCClient",
"calls",
"close",
"on",
"the",
"rpc",
"and",
"cleans",
"up",
"the",
"connection"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L195-L224 |
7,304 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | ContextList | func (r *RPCWrapper) ContextList() []string {
keylist := r.rpcClientMap.KeyList()
contextArray := []string{}
for _, key := range keylist {
if kstring, ok := key.(string); ok {
contextArray = append(contextArray, kstring)
}
}
return contextArray
} | go | func (r *RPCWrapper) ContextList() []string {
keylist := r.rpcClientMap.KeyList()
contextArray := []string{}
for _, key := range keylist {
if kstring, ok := key.(string); ok {
contextArray = append(contextArray, kstring)
}
}
return contextArray
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"ContextList",
"(",
")",
"[",
"]",
"string",
"{",
"keylist",
":=",
"r",
".",
"rpcClientMap",
".",
"KeyList",
"(",
")",
"\n",
"contextArray",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"key",... | // ContextList returns the list of active context managed by the rpcwrapper | [
"ContextList",
"returns",
"the",
"list",
"of",
"active",
"context",
"managed",
"by",
"the",
"rpcwrapper"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L227-L236 |
7,305 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | ProcessMessage | func (r *RPCWrapper) ProcessMessage(req *Request, secret string) bool {
return r.CheckValidity(req, secret)
} | go | func (r *RPCWrapper) ProcessMessage(req *Request, secret string) bool {
return r.CheckValidity(req, secret)
} | [
"func",
"(",
"r",
"*",
"RPCWrapper",
")",
"ProcessMessage",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
"{",
"return",
"r",
".",
"CheckValidity",
"(",
"req",
",",
"secret",
")",
"\n",
"}"
] | // ProcessMessage checks if the given request is valid | [
"ProcessMessage",
"checks",
"if",
"the",
"given",
"request",
"is",
"valid"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L239-L242 |
7,306 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | payloadHash | func payloadHash(payload interface{}) ([]byte, error) {
hash, err := hashstructure.Hash(payload, nil)
if err != nil {
return []byte{}, err
}
buf := make([]byte, 8)
binary.BigEndian.PutUint64(buf, hash)
return buf, nil
} | go | func payloadHash(payload interface{}) ([]byte, error) {
hash, err := hashstructure.Hash(payload, nil)
if err != nil {
return []byte{}, err
}
buf := make([]byte, 8)
binary.BigEndian.PutUint64(buf, hash)
return buf, nil
} | [
"func",
"payloadHash",
"(",
"payload",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"hash",
",",
"err",
":=",
"hashstructure",
".",
"Hash",
"(",
"payload",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // payloadHash returns the has of the payload | [
"payloadHash",
"returns",
"the",
"has",
"of",
"the",
"payload"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L245-L254 |
7,307 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go | RegisterTypes | func RegisterTypes() {
gob.Register(&secrets.CompactPKIPublicSecrets{})
gob.Register(&pkitokens.PKIJWTVerifier{})
gob.Register(&oidc.TokenVerifier{})
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Init_Request_Payload", *(&InitRequestPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Init_Response_Payload", *(&InitResponsePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Enforce_Payload", *(&EnforcePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.UnEnforce_Payload", *(&UnEnforcePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Stats_Payload", *(&StatsPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.UpdateSecrets_Payload", *(&UpdateSecretsPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.SetTargetNetworks_Payload", *(&SetTargetNetworksPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.EnableIPTablesPacketTracing_PayLoad", *(&EnableIPTablesPacketTracingPayLoad{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.EnableDatapathPacketTracing_PayLoad", *(&EnableDatapathPacketTracingPayLoad{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.DebugPacket_Payload", *(&DebugPacketPayload{}))
} | go | func RegisterTypes() {
gob.Register(&secrets.CompactPKIPublicSecrets{})
gob.Register(&pkitokens.PKIJWTVerifier{})
gob.Register(&oidc.TokenVerifier{})
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Init_Request_Payload", *(&InitRequestPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Init_Response_Payload", *(&InitResponsePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Enforce_Payload", *(&EnforcePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.UnEnforce_Payload", *(&UnEnforcePayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.Stats_Payload", *(&StatsPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.UpdateSecrets_Payload", *(&UpdateSecretsPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.SetTargetNetworks_Payload", *(&SetTargetNetworksPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.EnableIPTablesPacketTracing_PayLoad", *(&EnableIPTablesPacketTracingPayLoad{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.EnableDatapathPacketTracing_PayLoad", *(&EnableDatapathPacketTracingPayLoad{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.DebugPacket_Payload", *(&DebugPacketPayload{}))
} | [
"func",
"RegisterTypes",
"(",
")",
"{",
"gob",
".",
"Register",
"(",
"&",
"secrets",
".",
"CompactPKIPublicSecrets",
"{",
"}",
")",
"\n",
"gob",
".",
"Register",
"(",
"&",
"pkitokens",
".",
"PKIJWTVerifier",
"{",
"}",
")",
"\n",
"gob",
".",
"Register",
... | // RegisterTypes registers types that are exchanged between the controller and remoteenforcer | [
"RegisterTypes",
"registers",
"types",
"that",
"are",
"exchanged",
"between",
"the",
"controller",
"and",
"remoteenforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handle.go#L257-L274 |
7,308 | aporeto-inc/trireme-lib | monitor/registerer/registerer.go | New | func New() Registerer {
return ®isterer{
handlers: map[common.PUType]map[common.Event]common.EventHandler{},
}
} | go | func New() Registerer {
return ®isterer{
handlers: map[common.PUType]map[common.Event]common.EventHandler{},
}
} | [
"func",
"New",
"(",
")",
"Registerer",
"{",
"return",
"&",
"registerer",
"{",
"handlers",
":",
"map",
"[",
"common",
".",
"PUType",
"]",
"map",
"[",
"common",
".",
"Event",
"]",
"common",
".",
"EventHandler",
"{",
"}",
",",
"}",
"\n",
"}"
] | // New returns a new registerer | [
"New",
"returns",
"a",
"new",
"registerer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/registerer/registerer.go#L16-L21 |
7,309 | aporeto-inc/trireme-lib | monitor/registerer/registerer.go | RegisterProcessor | func (r *registerer) RegisterProcessor(puType common.PUType, ep processor.Processor) error {
if _, ok := r.handlers[puType]; ok {
return fmt.Errorf("Processor already registered for this PU type %d ", puType)
}
r.handlers[puType] = map[common.Event]common.EventHandler{}
r.addHandler(puType, common.EventStart, ep.Start)
r.addHandler(puType, common.EventStop, ep.Stop)
r.addHandler(puType, common.EventCreate, ep.Create)
r.addHandler(puType, common.EventDestroy, ep.Destroy)
r.addHandler(puType, common.EventPause, ep.Pause)
r.addHandler(puType, common.EventResync, ep.Resync)
return nil
} | go | func (r *registerer) RegisterProcessor(puType common.PUType, ep processor.Processor) error {
if _, ok := r.handlers[puType]; ok {
return fmt.Errorf("Processor already registered for this PU type %d ", puType)
}
r.handlers[puType] = map[common.Event]common.EventHandler{}
r.addHandler(puType, common.EventStart, ep.Start)
r.addHandler(puType, common.EventStop, ep.Stop)
r.addHandler(puType, common.EventCreate, ep.Create)
r.addHandler(puType, common.EventDestroy, ep.Destroy)
r.addHandler(puType, common.EventPause, ep.Pause)
r.addHandler(puType, common.EventResync, ep.Resync)
return nil
} | [
"func",
"(",
"r",
"*",
"registerer",
")",
"RegisterProcessor",
"(",
"puType",
"common",
".",
"PUType",
",",
"ep",
"processor",
".",
"Processor",
")",
"error",
"{",
"if",
"_",
",",
"ok",
":=",
"r",
".",
"handlers",
"[",
"puType",
"]",
";",
"ok",
"{",
... | // RegisterProcessor registers an event processor for a given PUTYpe. Only one
// processor is allowed for a given PU Type. | [
"RegisterProcessor",
"registers",
"an",
"event",
"processor",
"for",
"a",
"given",
"PUTYpe",
".",
"Only",
"one",
"processor",
"is",
"allowed",
"for",
"a",
"given",
"PU",
"Type",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/registerer/registerer.go#L25-L41 |
7,310 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | processApplicationTCPPacket | func (d *Datapath) processApplicationTCPPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (interface{}, error) {
if conn == nil {
return nil, nil
}
// State machine based on the flags
switch tcpPacket.GetTCPFlags() & packet.TCPSynAckMask {
case packet.TCPSynMask: //Processing SYN packet from Application
return d.processApplicationSynPacket(tcpPacket, context, conn)
case packet.TCPAckMask:
return nil, d.processApplicationAckPacket(tcpPacket, context, conn)
case packet.TCPSynAckMask:
return nil, d.processApplicationSynAckPacket(tcpPacket, context, conn)
default:
return nil, nil
}
} | go | func (d *Datapath) processApplicationTCPPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (interface{}, error) {
if conn == nil {
return nil, nil
}
// State machine based on the flags
switch tcpPacket.GetTCPFlags() & packet.TCPSynAckMask {
case packet.TCPSynMask: //Processing SYN packet from Application
return d.processApplicationSynPacket(tcpPacket, context, conn)
case packet.TCPAckMask:
return nil, d.processApplicationAckPacket(tcpPacket, context, conn)
case packet.TCPSynAckMask:
return nil, d.processApplicationSynAckPacket(tcpPacket, context, conn)
default:
return nil, nil
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processApplicationTCPPacket",
"(",
"tcpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"TCPConnection",
")",
"(",
"interface",
"{",
"}",
... | // processApplicationTCPPacket processes a TCP packet and dispatches it to other methods based on the flags | [
"processApplicationTCPPacket",
"processes",
"a",
"TCP",
"packet",
"and",
"dispatches",
"it",
"to",
"other",
"methods",
"based",
"on",
"the",
"flags"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L276-L295 |
7,311 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | processApplicationSynPacket | func (d *Datapath) processApplicationSynPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (interface{}, error) {
// If the packet is not in target networks then look into the external services application cache to
// make a decision whether the packet should be forwarded. For target networks with external services
// network syn/ack accepts the packet if it belongs to external services.
_, pkt, perr := d.targetNetworks.GetMatchingAction(tcpPacket.DestinationAddress(), tcpPacket.DestPort())
if perr != nil {
report, policy, perr := context.ApplicationACLPolicyFromAddr(tcpPacket.DestinationAddress(), tcpPacket.DestPort())
if perr == nil && policy.Action.Accepted() {
return nil, nil
}
d.reportExternalServiceFlow(context, report, pkt, true, tcpPacket)
return nil, fmt.Errorf("No acls found for external services. Dropping application syn packet")
}
if policy, err := context.RetrieveCachedExternalFlowPolicy(tcpPacket.DestinationAddress().String() + ":" + strconv.Itoa(int(tcpPacket.DestPort()))); err == nil {
d.appOrigConnectionTracker.AddOrUpdate(tcpPacket.L4FlowHash(), conn)
d.sourcePortConnectionCache.AddOrUpdate(tcpPacket.SourcePortHash(packet.PacketTypeApplication), conn)
return policy, nil
}
// We are now processing as a Trireme packet that needs authorization headers
// Create TCP Option
tcpOptions := d.createTCPAuthenticationOption([]byte{})
// Create a token
tcpData, err := d.tokenAccessor.CreateSynPacketToken(context, &conn.Auth)
if err != nil {
return nil, err
}
// Set the state indicating that we send out a Syn packet
conn.SetState(connection.TCPSynSend)
// Poplate the caches to track the connection
hash := tcpPacket.L4FlowHash()
d.appOrigConnectionTracker.AddOrUpdate(hash, conn)
d.sourcePortConnectionCache.AddOrUpdate(tcpPacket.SourcePortHash(packet.PacketTypeApplication), conn)
// Attach the tags to the packet and accept the packet
return nil, tcpPacket.TCPDataAttach(tcpOptions, tcpData)
} | go | func (d *Datapath) processApplicationSynPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (interface{}, error) {
// If the packet is not in target networks then look into the external services application cache to
// make a decision whether the packet should be forwarded. For target networks with external services
// network syn/ack accepts the packet if it belongs to external services.
_, pkt, perr := d.targetNetworks.GetMatchingAction(tcpPacket.DestinationAddress(), tcpPacket.DestPort())
if perr != nil {
report, policy, perr := context.ApplicationACLPolicyFromAddr(tcpPacket.DestinationAddress(), tcpPacket.DestPort())
if perr == nil && policy.Action.Accepted() {
return nil, nil
}
d.reportExternalServiceFlow(context, report, pkt, true, tcpPacket)
return nil, fmt.Errorf("No acls found for external services. Dropping application syn packet")
}
if policy, err := context.RetrieveCachedExternalFlowPolicy(tcpPacket.DestinationAddress().String() + ":" + strconv.Itoa(int(tcpPacket.DestPort()))); err == nil {
d.appOrigConnectionTracker.AddOrUpdate(tcpPacket.L4FlowHash(), conn)
d.sourcePortConnectionCache.AddOrUpdate(tcpPacket.SourcePortHash(packet.PacketTypeApplication), conn)
return policy, nil
}
// We are now processing as a Trireme packet that needs authorization headers
// Create TCP Option
tcpOptions := d.createTCPAuthenticationOption([]byte{})
// Create a token
tcpData, err := d.tokenAccessor.CreateSynPacketToken(context, &conn.Auth)
if err != nil {
return nil, err
}
// Set the state indicating that we send out a Syn packet
conn.SetState(connection.TCPSynSend)
// Poplate the caches to track the connection
hash := tcpPacket.L4FlowHash()
d.appOrigConnectionTracker.AddOrUpdate(hash, conn)
d.sourcePortConnectionCache.AddOrUpdate(tcpPacket.SourcePortHash(packet.PacketTypeApplication), conn)
// Attach the tags to the packet and accept the packet
return nil, tcpPacket.TCPDataAttach(tcpOptions, tcpData)
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processApplicationSynPacket",
"(",
"tcpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"TCPConnection",
")",
"(",
"interface",
"{",
"}",
... | // processApplicationSynPacket processes a single Syn Packet | [
"processApplicationSynPacket",
"processes",
"a",
"single",
"Syn",
"Packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L298-L342 |
7,312 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | processApplicationSynAckPacket | func (d *Datapath) processApplicationSynAckPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) error {
// if the traffic belongs to the same pu, let it go
if conn.GetState() == connection.TCPData && conn.IsLoopbackConnection() {
return nil
}
// If we are already in the connection.TCPData, it means that this is an external flow
// At this point we can release the flow to the kernel by updating conntrack
// We can also clean up the state since we are not going to see any more
// packets from this connection.
if conn.GetState() == connection.TCPData && !conn.ServiceConnection {
if err := d.conntrack.UpdateApplicationFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil {
zap.L().Error("Failed to update conntrack entry for flow at SynAck packet",
zap.String("context", string(conn.Auth.LocalContext)),
zap.String("app-conn", tcpPacket.L4ReverseFlowHash()),
zap.String("state", fmt.Sprintf("%d", conn.GetState())),
zap.Error(err),
)
}
err1 := d.netOrigConnectionTracker.Remove(tcpPacket.L4ReverseFlowHash())
err2 := d.appReplyConnectionTracker.Remove(tcpPacket.L4FlowHash())
if err1 != nil || err2 != nil {
zap.L().Debug("Failed to remove cache entries")
}
return nil
}
// We now process packets that need authorization options
// Create TCP Option
tcpOptions := d.createTCPAuthenticationOption([]byte{})
claimsHeader := claimsheader.NewClaimsHeader(
claimsheader.OptionEncrypt(conn.PacketFlowPolicy.Action.Encrypted()),
)
tcpData, err := d.tokenAccessor.CreateSynAckPacketToken(context, &conn.Auth, claimsHeader)
if err != nil {
return err
}
// Set the state for future reference
conn.SetState(connection.TCPSynAckSend)
// Attach the tags to the packet
return tcpPacket.TCPDataAttach(tcpOptions, tcpData)
} | go | func (d *Datapath) processApplicationSynAckPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) error {
// if the traffic belongs to the same pu, let it go
if conn.GetState() == connection.TCPData && conn.IsLoopbackConnection() {
return nil
}
// If we are already in the connection.TCPData, it means that this is an external flow
// At this point we can release the flow to the kernel by updating conntrack
// We can also clean up the state since we are not going to see any more
// packets from this connection.
if conn.GetState() == connection.TCPData && !conn.ServiceConnection {
if err := d.conntrack.UpdateApplicationFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil {
zap.L().Error("Failed to update conntrack entry for flow at SynAck packet",
zap.String("context", string(conn.Auth.LocalContext)),
zap.String("app-conn", tcpPacket.L4ReverseFlowHash()),
zap.String("state", fmt.Sprintf("%d", conn.GetState())),
zap.Error(err),
)
}
err1 := d.netOrigConnectionTracker.Remove(tcpPacket.L4ReverseFlowHash())
err2 := d.appReplyConnectionTracker.Remove(tcpPacket.L4FlowHash())
if err1 != nil || err2 != nil {
zap.L().Debug("Failed to remove cache entries")
}
return nil
}
// We now process packets that need authorization options
// Create TCP Option
tcpOptions := d.createTCPAuthenticationOption([]byte{})
claimsHeader := claimsheader.NewClaimsHeader(
claimsheader.OptionEncrypt(conn.PacketFlowPolicy.Action.Encrypted()),
)
tcpData, err := d.tokenAccessor.CreateSynAckPacketToken(context, &conn.Auth, claimsHeader)
if err != nil {
return err
}
// Set the state for future reference
conn.SetState(connection.TCPSynAckSend)
// Attach the tags to the packet
return tcpPacket.TCPDataAttach(tcpOptions, tcpData)
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processApplicationSynAckPacket",
"(",
"tcpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"TCPConnection",
")",
"error",
"{",
"// if the tr... | // processApplicationSynAckPacket processes an application SynAck packet | [
"processApplicationSynAckPacket",
"processes",
"an",
"application",
"SynAck",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L345-L403 |
7,313 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | processNetworkTCPPacket | func (d *Datapath) processNetworkTCPPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (action interface{}, claims *tokens.ConnectionClaims, err error) {
if conn == nil {
return nil, nil, nil
}
// Update connection state in the internal state machine tracker
switch tcpPacket.GetTCPFlags() & packet.TCPSynAckMask {
case packet.TCPSynMask:
return d.processNetworkSynPacket(context, conn, tcpPacket)
case packet.TCPAckMask:
return d.processNetworkAckPacket(context, conn, tcpPacket)
case packet.TCPSynAckMask:
return d.processNetworkSynAckPacket(context, conn, tcpPacket)
default: // Ignore any other packet
return nil, nil, nil
}
} | go | func (d *Datapath) processNetworkTCPPacket(tcpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.TCPConnection) (action interface{}, claims *tokens.ConnectionClaims, err error) {
if conn == nil {
return nil, nil, nil
}
// Update connection state in the internal state machine tracker
switch tcpPacket.GetTCPFlags() & packet.TCPSynAckMask {
case packet.TCPSynMask:
return d.processNetworkSynPacket(context, conn, tcpPacket)
case packet.TCPAckMask:
return d.processNetworkAckPacket(context, conn, tcpPacket)
case packet.TCPSynAckMask:
return d.processNetworkSynAckPacket(context, conn, tcpPacket)
default: // Ignore any other packet
return nil, nil, nil
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processNetworkTCPPacket",
"(",
"tcpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"TCPConnection",
")",
"(",
"action",
"interface",
"{",... | // processNetworkTCPPacket processes a network TCP packet and dispatches it to different methods based on the flags | [
"processNetworkTCPPacket",
"processes",
"a",
"network",
"TCP",
"packet",
"and",
"dispatches",
"it",
"to",
"different",
"methods",
"based",
"on",
"the",
"flags"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L524-L545 |
7,314 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | createTCPAuthenticationOption | func (d *Datapath) createTCPAuthenticationOption(token []byte) []byte {
tokenLen := uint8(len(token))
options := []byte{packet.TCPAuthenticationOption, enforcerconstants.TCPAuthenticationOptionBaseLen + tokenLen, 0, 0}
if tokenLen != 0 {
options = append(options, token...)
}
return options
} | go | func (d *Datapath) createTCPAuthenticationOption(token []byte) []byte {
tokenLen := uint8(len(token))
options := []byte{packet.TCPAuthenticationOption, enforcerconstants.TCPAuthenticationOptionBaseLen + tokenLen, 0, 0}
if tokenLen != 0 {
options = append(options, token...)
}
return options
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"createTCPAuthenticationOption",
"(",
"token",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"tokenLen",
":=",
"uint8",
"(",
"len",
"(",
"token",
")",
")",
"\n",
"options",
":=",
"[",
"]",
"byte",
"{",
"packet"... | // createTCPAuthenticationOption creates the TCP authentication option - | [
"createTCPAuthenticationOption",
"creates",
"the",
"TCP",
"authentication",
"option",
"-"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L903-L913 |
7,315 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | appSynRetrieveState | func (d *Datapath) appSynRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
context, err := d.contextFromIP(true, p.Mark, p.SourcePort(), packet.IPProtocolTCP)
if err != nil {
return nil, err
}
if conn, err := d.appOrigConnectionTracker.GetReset(p.L4FlowHash(), 0); err == nil {
return conn.(*connection.TCPConnection), nil
}
return connection.NewTCPConnection(context, p), nil
} | go | func (d *Datapath) appSynRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
context, err := d.contextFromIP(true, p.Mark, p.SourcePort(), packet.IPProtocolTCP)
if err != nil {
return nil, err
}
if conn, err := d.appOrigConnectionTracker.GetReset(p.L4FlowHash(), 0); err == nil {
return conn.(*connection.TCPConnection), nil
}
return connection.NewTCPConnection(context, p), nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"appSynRetrieveState",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"*",
"connection",
".",
"TCPConnection",
",",
"error",
")",
"{",
"context",
",",
"err",
":=",
"d",
".",
"contextFromIP",
"(",
"true",
",",
... | // appSynRetrieveState retrieves state for the the application Syn packet.
// It creates a new connection by default | [
"appSynRetrieveState",
"retrieves",
"state",
"for",
"the",
"the",
"application",
"Syn",
"packet",
".",
"It",
"creates",
"a",
"new",
"connection",
"by",
"default"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L917-L928 |
7,316 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | appRetrieveState | func (d *Datapath) appRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
hash := p.L4FlowHash()
// If this ack packet is from Server, Did we see a network Syn for this server PU?
conn, err := d.appReplyConnectionTracker.GetReset(hash, 0)
if err == nil {
if uerr := updateTimer(d.appReplyConnectionTracker, hash, conn.(*connection.TCPConnection)); uerr != nil {
zap.L().Error("entry expired just before updating the timer", zap.String("flow", hash))
return nil, uerr
}
return conn.(*connection.TCPConnection), nil
}
// If this ack packet is from client, Did we see an Application Syn packet before?
conn, err = d.appOrigConnectionTracker.GetReset(hash, 0)
if err == nil {
if uerr := updateTimer(d.appOrigConnectionTracker, hash, conn.(*connection.TCPConnection)); uerr != nil {
return nil, uerr
}
return conn.(*connection.TCPConnection), nil
}
if p.GetTCPFlags()&packet.TCPSynAckMask == packet.TCPAckMask {
// Let's try if its an existing connection
context, err := d.contextFromIP(true, p.Mark, p.SourcePort(), packet.IPProtocolTCP)
if err != nil {
return nil, errors.New("No context in app processing")
}
conn = connection.NewTCPConnection(context, p)
conn.(*connection.TCPConnection).SetState(connection.UnknownState)
return conn.(*connection.TCPConnection), nil
}
return nil, errNoConnFound
} | go | func (d *Datapath) appRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
hash := p.L4FlowHash()
// If this ack packet is from Server, Did we see a network Syn for this server PU?
conn, err := d.appReplyConnectionTracker.GetReset(hash, 0)
if err == nil {
if uerr := updateTimer(d.appReplyConnectionTracker, hash, conn.(*connection.TCPConnection)); uerr != nil {
zap.L().Error("entry expired just before updating the timer", zap.String("flow", hash))
return nil, uerr
}
return conn.(*connection.TCPConnection), nil
}
// If this ack packet is from client, Did we see an Application Syn packet before?
conn, err = d.appOrigConnectionTracker.GetReset(hash, 0)
if err == nil {
if uerr := updateTimer(d.appOrigConnectionTracker, hash, conn.(*connection.TCPConnection)); uerr != nil {
return nil, uerr
}
return conn.(*connection.TCPConnection), nil
}
if p.GetTCPFlags()&packet.TCPSynAckMask == packet.TCPAckMask {
// Let's try if its an existing connection
context, err := d.contextFromIP(true, p.Mark, p.SourcePort(), packet.IPProtocolTCP)
if err != nil {
return nil, errors.New("No context in app processing")
}
conn = connection.NewTCPConnection(context, p)
conn.(*connection.TCPConnection).SetState(connection.UnknownState)
return conn.(*connection.TCPConnection), nil
}
return nil, errNoConnFound
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"appRetrieveState",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"*",
"connection",
".",
"TCPConnection",
",",
"error",
")",
"{",
"hash",
":=",
"p",
".",
"L4FlowHash",
"(",
")",
"\n\n",
"// If this ack packet ... | // appRetrieveState retrieves the state for the rest of the application packets. It
// returns an error if it cannot find the state | [
"appRetrieveState",
"retrieves",
"the",
"state",
"for",
"the",
"rest",
"of",
"the",
"application",
"packets",
".",
"It",
"returns",
"an",
"error",
"if",
"it",
"cannot",
"find",
"the",
"state"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L950-L985 |
7,317 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | netSynRetrieveState | func (d *Datapath) netSynRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
context, err := d.contextFromIP(false, p.Mark, p.DestPort(), packet.IPProtocolTCP)
if err == nil {
if conn, err := d.netOrigConnectionTracker.GetReset(p.L4FlowHash(), 0); err == nil {
return conn.(*connection.TCPConnection), nil
}
return connection.NewTCPConnection(context, p), nil
}
//This needs to hit only for local processes never for containers
//Don't return an error create a dummy context and return it so we truncate the packet before we send it up
if d.mode != constants.RemoteContainer {
//we will create the bare minimum needed to exercise our stack
//We need this syn to look similar to what we will pass on the retry
//so we setup enough for us to identify this request in the later stages
// Remove any of our data from the packet.
if err = p.CheckTCPAuthenticationOption(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Syn received with tcp option not set", zap.Error(err))
return nil, errNonPUTraffic
}
if err = p.TCPDataDetach(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Error removing TCP Data", zap.Error(err))
return nil, errNonPUTraffic
}
p.DropTCPDetachedBytes()
p.UpdateTCPChecksum()
return nil, errNonPUTraffic
}
return nil, errInvalidNetState
} | go | func (d *Datapath) netSynRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
context, err := d.contextFromIP(false, p.Mark, p.DestPort(), packet.IPProtocolTCP)
if err == nil {
if conn, err := d.netOrigConnectionTracker.GetReset(p.L4FlowHash(), 0); err == nil {
return conn.(*connection.TCPConnection), nil
}
return connection.NewTCPConnection(context, p), nil
}
//This needs to hit only for local processes never for containers
//Don't return an error create a dummy context and return it so we truncate the packet before we send it up
if d.mode != constants.RemoteContainer {
//we will create the bare minimum needed to exercise our stack
//We need this syn to look similar to what we will pass on the retry
//so we setup enough for us to identify this request in the later stages
// Remove any of our data from the packet.
if err = p.CheckTCPAuthenticationOption(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Syn received with tcp option not set", zap.Error(err))
return nil, errNonPUTraffic
}
if err = p.TCPDataDetach(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Error removing TCP Data", zap.Error(err))
return nil, errNonPUTraffic
}
p.DropTCPDetachedBytes()
p.UpdateTCPChecksum()
return nil, errNonPUTraffic
}
return nil, errInvalidNetState
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"netSynRetrieveState",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"*",
"connection",
".",
"TCPConnection",
",",
"error",
")",
"{",
"context",
",",
"err",
":=",
"d",
".",
"contextFromIP",
"(",
"false",
",",... | // netSynRetrieveState retrieves the state for the Syn packets on the network.
// Obviously if no state is found, it generates a new connection record. | [
"netSynRetrieveState",
"retrieves",
"the",
"state",
"for",
"the",
"Syn",
"packets",
"on",
"the",
"network",
".",
"Obviously",
"if",
"no",
"state",
"is",
"found",
"it",
"generates",
"a",
"new",
"connection",
"record",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L989-L1026 |
7,318 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | netSynAckRetrieveState | func (d *Datapath) netSynAckRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
conn, err := d.sourcePortConnectionCache.GetReset(p.SourcePortHash(packet.PacketTypeNetwork), 0)
if err != nil {
return nil, errNonPUTraffic
}
return conn.(*connection.TCPConnection), nil
} | go | func (d *Datapath) netSynAckRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
conn, err := d.sourcePortConnectionCache.GetReset(p.SourcePortHash(packet.PacketTypeNetwork), 0)
if err != nil {
return nil, errNonPUTraffic
}
return conn.(*connection.TCPConnection), nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"netSynAckRetrieveState",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"*",
"connection",
".",
"TCPConnection",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"d",
".",
"sourcePortConnectionCache",
".",
"Ge... | // netSynAckRetrieveState retrieves the state for SynAck packets at the network
// It relies on the source port cache for that | [
"netSynAckRetrieveState",
"retrieves",
"the",
"state",
"for",
"SynAck",
"packets",
"at",
"the",
"network",
"It",
"relies",
"on",
"the",
"source",
"port",
"cache",
"for",
"that"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L1030-L1038 |
7,319 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | netRetrieveState | func (d *Datapath) netRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
hash := p.L4FlowHash()
// Did we see a network syn/ack packet? (PU is a client)
conn, err := d.netReplyConnectionTracker.GetReset(hash, 0)
if err == nil {
if err = updateTimer(d.netReplyConnectionTracker, hash, conn.(*connection.TCPConnection)); err != nil {
return nil, err
}
return conn.(*connection.TCPConnection), nil
}
// Did we see a network Syn packet before? (PU is a server)
conn, err = d.netOrigConnectionTracker.GetReset(hash, 0)
if err == nil {
if err = updateTimer(d.netOrigConnectionTracker, hash, conn.(*connection.TCPConnection)); err != nil {
return nil, err
}
return conn.(*connection.TCPConnection), nil
}
// We reach in this state for a client PU only when the service connection(encrypt) sends data sparsely.
// Packets are dropped when this happens, and that is a BUG!!!
// For the server PU we mark the connection in the unknown state.
if p.GetTCPFlags()&packet.TCPSynAckMask == packet.TCPAckMask {
// Let's try if its an existing connection
context, cerr := d.contextFromIP(false, p.Mark, p.DestPort(), packet.IPProtocolTCP)
if cerr != nil {
return nil, err
}
conn = connection.NewTCPConnection(context, p)
conn.(*connection.TCPConnection).SetState(connection.UnknownState)
return conn.(*connection.TCPConnection), nil
}
return nil, errInvalidNetState
} | go | func (d *Datapath) netRetrieveState(p *packet.Packet) (*connection.TCPConnection, error) {
hash := p.L4FlowHash()
// Did we see a network syn/ack packet? (PU is a client)
conn, err := d.netReplyConnectionTracker.GetReset(hash, 0)
if err == nil {
if err = updateTimer(d.netReplyConnectionTracker, hash, conn.(*connection.TCPConnection)); err != nil {
return nil, err
}
return conn.(*connection.TCPConnection), nil
}
// Did we see a network Syn packet before? (PU is a server)
conn, err = d.netOrigConnectionTracker.GetReset(hash, 0)
if err == nil {
if err = updateTimer(d.netOrigConnectionTracker, hash, conn.(*connection.TCPConnection)); err != nil {
return nil, err
}
return conn.(*connection.TCPConnection), nil
}
// We reach in this state for a client PU only when the service connection(encrypt) sends data sparsely.
// Packets are dropped when this happens, and that is a BUG!!!
// For the server PU we mark the connection in the unknown state.
if p.GetTCPFlags()&packet.TCPSynAckMask == packet.TCPAckMask {
// Let's try if its an existing connection
context, cerr := d.contextFromIP(false, p.Mark, p.DestPort(), packet.IPProtocolTCP)
if cerr != nil {
return nil, err
}
conn = connection.NewTCPConnection(context, p)
conn.(*connection.TCPConnection).SetState(connection.UnknownState)
return conn.(*connection.TCPConnection), nil
}
return nil, errInvalidNetState
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"netRetrieveState",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"*",
"connection",
".",
"TCPConnection",
",",
"error",
")",
"{",
"hash",
":=",
"p",
".",
"L4FlowHash",
"(",
")",
"\n\n",
"// Did we see a networ... | // netRetrieveState retrieves the state of a network connection. Use the flow caches for that | [
"netRetrieveState",
"retrieves",
"the",
"state",
"of",
"a",
"network",
"connection",
".",
"Use",
"the",
"flow",
"caches",
"for",
"that"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L1041-L1079 |
7,320 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | updateTimer | func updateTimer(c cache.DataStore, hash string, conn *connection.TCPConnection) error {
conn.RLock()
defer conn.RUnlock()
if conn.ServiceConnection && conn.TimeOut > 0 {
return c.SetTimeOut(hash, conn.TimeOut)
}
return nil
} | go | func updateTimer(c cache.DataStore, hash string, conn *connection.TCPConnection) error {
conn.RLock()
defer conn.RUnlock()
if conn.ServiceConnection && conn.TimeOut > 0 {
return c.SetTimeOut(hash, conn.TimeOut)
}
return nil
} | [
"func",
"updateTimer",
"(",
"c",
"cache",
".",
"DataStore",
",",
"hash",
"string",
",",
"conn",
"*",
"connection",
".",
"TCPConnection",
")",
"error",
"{",
"conn",
".",
"RLock",
"(",
")",
"\n",
"defer",
"conn",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
... | // updateTimer updates the timers for the service connections | [
"updateTimer",
"updates",
"the",
"timers",
"for",
"the",
"service",
"connections"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L1082-L1090 |
7,321 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | releaseFlow | func (d *Datapath) releaseFlow(context *pucontext.PUContext, report *policy.FlowPolicy, action *policy.FlowPolicy, tcpPacket *packet.Packet) {
if err := d.appOrigConnectionTracker.Remove(tcpPacket.L4ReverseFlowHash()); err != nil {
zap.L().Debug("Failed to clean cache appOrigConnectionTracker", zap.Error(err))
}
if err := d.sourcePortConnectionCache.Remove(tcpPacket.SourcePortHash(packet.PacketTypeNetwork)); err != nil {
zap.L().Debug("Failed to clean cache sourcePortConnectionCache", zap.Error(err))
}
if err := d.conntrack.UpdateNetworkFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil {
zap.L().Error("Failed to update conntrack table",
zap.String("app-conn", tcpPacket.L4ReverseFlowHash()),
zap.Error(err))
}
d.reportReverseExternalServiceFlow(context, report, action, true, tcpPacket)
} | go | func (d *Datapath) releaseFlow(context *pucontext.PUContext, report *policy.FlowPolicy, action *policy.FlowPolicy, tcpPacket *packet.Packet) {
if err := d.appOrigConnectionTracker.Remove(tcpPacket.L4ReverseFlowHash()); err != nil {
zap.L().Debug("Failed to clean cache appOrigConnectionTracker", zap.Error(err))
}
if err := d.sourcePortConnectionCache.Remove(tcpPacket.SourcePortHash(packet.PacketTypeNetwork)); err != nil {
zap.L().Debug("Failed to clean cache sourcePortConnectionCache", zap.Error(err))
}
if err := d.conntrack.UpdateNetworkFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil {
zap.L().Error("Failed to update conntrack table",
zap.String("app-conn", tcpPacket.L4ReverseFlowHash()),
zap.Error(err))
}
d.reportReverseExternalServiceFlow(context, report, action, true, tcpPacket)
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"releaseFlow",
"(",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"action",
"*",
"policy",
".",
"FlowPolicy",
",",
"tcpPacket",
"*",
"packet",
".",
"Packet",
"... | // releaseFlow releases the flow and updates the conntrack table | [
"releaseFlow",
"releases",
"the",
"flow",
"and",
"updates",
"the",
"conntrack",
"table"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L1093-L1117 |
7,322 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_tcp.go | releaseUnmonitoredFlow | func (d *Datapath) releaseUnmonitoredFlow(tcpPacket *packet.Packet) {
zap.L().Debug("Releasing flow", zap.String("flow", tcpPacket.L4FlowHash()))
if err := d.conntrack.UpdateNetworkFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil && !netlink.IsNotExist(errors.Cause(err)) {
zap.L().Error("Failed to update conntrack table", zap.Error(err))
}
} | go | func (d *Datapath) releaseUnmonitoredFlow(tcpPacket *packet.Packet) {
zap.L().Debug("Releasing flow", zap.String("flow", tcpPacket.L4FlowHash()))
if err := d.conntrack.UpdateNetworkFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil && !netlink.IsNotExist(errors.Cause(err)) {
zap.L().Error("Failed to update conntrack table", zap.Error(err))
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"releaseUnmonitoredFlow",
"(",
"tcpPacket",
"*",
"packet",
".",
"Packet",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"tcpPacket",
".",... | // releaseUnmonitoredFlow releases the flow and updates the conntrack table | [
"releaseUnmonitoredFlow",
"releases",
"the",
"flow",
"and",
"updates",
"the",
"conntrack",
"table"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_tcp.go#L1120-L1133 |
7,323 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | NewMockSupervisor | func NewMockSupervisor(ctrl *gomock.Controller) *MockSupervisor {
mock := &MockSupervisor{ctrl: ctrl}
mock.recorder = &MockSupervisorMockRecorder{mock}
return mock
} | go | func NewMockSupervisor(ctrl *gomock.Controller) *MockSupervisor {
mock := &MockSupervisor{ctrl: ctrl}
mock.recorder = &MockSupervisorMockRecorder{mock}
return mock
} | [
"func",
"NewMockSupervisor",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSupervisor",
"{",
"mock",
":=",
"&",
"MockSupervisor",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSupervisorMockRecorder",
"{",
"mock... | // NewMockSupervisor creates a new mock instance
// nolint | [
"NewMockSupervisor",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L34-L38 |
7,324 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | Supervise | func (m *MockSupervisor) Supervise(contextID string, puInfo *policy.PUInfo) error {
ret := m.ctrl.Call(m, "Supervise", contextID, puInfo)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockSupervisor) Supervise(contextID string, puInfo *policy.PUInfo) error {
ret := m.ctrl.Call(m, "Supervise", contextID, puInfo)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSupervisor",
")",
"Supervise",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"pu... | // Supervise mocks base method
// nolint | [
"Supervise",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L48-L52 |
7,325 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | Supervise | func (mr *MockSupervisorMockRecorder) Supervise(contextID, puInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Supervise", reflect.TypeOf((*MockSupervisor)(nil).Supervise), contextID, puInfo)
} | go | func (mr *MockSupervisorMockRecorder) Supervise(contextID, puInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Supervise", reflect.TypeOf((*MockSupervisor)(nil).Supervise), contextID, puInfo)
} | [
"func",
"(",
"mr",
"*",
"MockSupervisorMockRecorder",
")",
"Supervise",
"(",
"contextID",
",",
"puInfo",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",... | // Supervise indicates an expected call of Supervise
// nolint | [
"Supervise",
"indicates",
"an",
"expected",
"call",
"of",
"Supervise",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L56-L58 |
7,326 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | Unsupervise | func (m *MockSupervisor) Unsupervise(contextID string) error {
ret := m.ctrl.Call(m, "Unsupervise", contextID)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockSupervisor) Unsupervise(contextID string) error {
ret := m.ctrl.Call(m, "Unsupervise", contextID)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSupervisor",
")",
"Unsupervise",
"(",
"contextID",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0... | // Unsupervise mocks base method
// nolint | [
"Unsupervise",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L62-L66 |
7,327 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | SetTargetNetworks | func (m *MockSupervisor) SetTargetNetworks(cfg *runtime.Configuration) error {
ret := m.ctrl.Call(m, "SetTargetNetworks", cfg)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockSupervisor) SetTargetNetworks(cfg *runtime.Configuration) error {
ret := m.ctrl.Call(m, "SetTargetNetworks", cfg)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSupervisor",
")",
"SetTargetNetworks",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"cfg",
")",
"\n",
"ret0",
",",
"_",
... | // SetTargetNetworks mocks base method
// nolint | [
"SetTargetNetworks",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L90-L94 |
7,328 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | NewMockImplementor | func NewMockImplementor(ctrl *gomock.Controller) *MockImplementor {
mock := &MockImplementor{ctrl: ctrl}
mock.recorder = &MockImplementorMockRecorder{mock}
return mock
} | go | func NewMockImplementor(ctrl *gomock.Controller) *MockImplementor {
mock := &MockImplementor{ctrl: ctrl}
mock.recorder = &MockImplementorMockRecorder{mock}
return mock
} | [
"func",
"NewMockImplementor",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockImplementor",
"{",
"mock",
":=",
"&",
"MockImplementor",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockImplementorMockRecorder",
"{",
"... | // NewMockImplementor creates a new mock instance
// nolint | [
"NewMockImplementor",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L145-L149 |
7,329 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | ConfigureRules | func (m *MockImplementor) ConfigureRules(version int, contextID string, containerInfo *policy.PUInfo) error {
ret := m.ctrl.Call(m, "ConfigureRules", version, contextID, containerInfo)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockImplementor) ConfigureRules(version int, contextID string, containerInfo *policy.PUInfo) error {
ret := m.ctrl.Call(m, "ConfigureRules", version, contextID, containerInfo)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockImplementor",
")",
"ConfigureRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
... | // ConfigureRules mocks base method
// nolint | [
"ConfigureRules",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L159-L163 |
7,330 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | ConfigureRules | func (mr *MockImplementorMockRecorder) ConfigureRules(version, contextID, containerInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureRules", reflect.TypeOf((*MockImplementor)(nil).ConfigureRules), version, contextID, containerInfo)
} | go | func (mr *MockImplementorMockRecorder) ConfigureRules(version, contextID, containerInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureRules", reflect.TypeOf((*MockImplementor)(nil).ConfigureRules), version, contextID, containerInfo)
} | [
"func",
"(",
"mr",
"*",
"MockImplementorMockRecorder",
")",
"ConfigureRules",
"(",
"version",
",",
"contextID",
",",
"containerInfo",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithM... | // ConfigureRules indicates an expected call of ConfigureRules
// nolint | [
"ConfigureRules",
"indicates",
"an",
"expected",
"call",
"of",
"ConfigureRules",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L167-L169 |
7,331 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | DeleteRules | func (m *MockImplementor) DeleteRules(version int, context, tcpPorts, udpPorts, mark, uid, proxyPort string, puType common.PUType) error {
ret := m.ctrl.Call(m, "DeleteRules", version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockImplementor) DeleteRules(version int, context, tcpPorts, udpPorts, mark, uid, proxyPort string, puType common.PUType) error {
ret := m.ctrl.Call(m, "DeleteRules", version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockImplementor",
")",
"DeleteRules",
"(",
"version",
"int",
",",
"context",
",",
"tcpPorts",
",",
"udpPorts",
",",
"mark",
",",
"uid",
",",
"proxyPort",
"string",
",",
"puType",
"common",
".",
"PUType",
")",
"error",
"{",
"ret",
... | // DeleteRules mocks base method
// nolint | [
"DeleteRules",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L187-L191 |
7,332 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | DeleteRules | func (mr *MockImplementorMockRecorder) DeleteRules(version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRules", reflect.TypeOf((*MockImplementor)(nil).DeleteRules), version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
} | go | func (mr *MockImplementorMockRecorder) DeleteRules(version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRules", reflect.TypeOf((*MockImplementor)(nil).DeleteRules), version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
} | [
"func",
"(",
"mr",
"*",
"MockImplementorMockRecorder",
")",
"DeleteRules",
"(",
"version",
",",
"context",
",",
"tcpPorts",
",",
"udpPorts",
",",
"mark",
",",
"uid",
",",
"proxyPort",
",",
"puType",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
... | // DeleteRules indicates an expected call of DeleteRules
// nolint | [
"DeleteRules",
"indicates",
"an",
"expected",
"call",
"of",
"DeleteRules",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L195-L197 |
7,333 | aporeto-inc/trireme-lib | controller/internal/supervisor/mocksupervisor/mocksupervisor.go | ACLProvider | func (m *MockImplementor) ACLProvider() aclprovider.IptablesProvider {
ret := m.ctrl.Call(m, "ACLProvider")
ret0, _ := ret[0].(aclprovider.IptablesProvider)
return ret0
} | go | func (m *MockImplementor) ACLProvider() aclprovider.IptablesProvider {
ret := m.ctrl.Call(m, "ACLProvider")
ret0, _ := ret[0].(aclprovider.IptablesProvider)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockImplementor",
")",
"ACLProvider",
"(",
")",
"aclprovider",
".",
"IptablesProvider",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
"... | // ACLProvider mocks base method
// nolint | [
"ACLProvider",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/mocksupervisor/mocksupervisor.go#L243-L247 |
7,334 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | NewEventServer | func NewEventServer(address string, registerer registerer.Registerer) (*EventServer, error) {
// Cleanup the socket first.
if _, err := os.Stat(address); err == nil {
if err := os.Remove(address); err != nil {
return nil, fmt.Errorf("Cannot create clean up socket: %s", err)
}
}
return &EventServer{
socketPath: address,
registerer: registerer,
}, nil
} | go | func NewEventServer(address string, registerer registerer.Registerer) (*EventServer, error) {
// Cleanup the socket first.
if _, err := os.Stat(address); err == nil {
if err := os.Remove(address); err != nil {
return nil, fmt.Errorf("Cannot create clean up socket: %s", err)
}
}
return &EventServer{
socketPath: address,
registerer: registerer,
}, nil
} | [
"func",
"NewEventServer",
"(",
"address",
"string",
",",
"registerer",
"registerer",
".",
"Registerer",
")",
"(",
"*",
"EventServer",
",",
"error",
")",
"{",
"// Cleanup the socket first.",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"address",
")",... | // NewEventServer creates a new event server | [
"NewEventServer",
"creates",
"a",
"new",
"event",
"server"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L28-L41 |
7,335 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | ServeHTTP | func (e *EventServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
e.create(w, r)
} | go | func (e *EventServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
e.create(w, r)
} | [
"func",
"(",
"e",
"*",
"EventServer",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"e",
".",
"create",
"(",
"w",
",",
"r",
")",
"\n",
"}"
] | // ServeHTTP is called for every request. | [
"ServeHTTP",
"is",
"called",
"for",
"every",
"request",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L44-L46 |
7,336 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | Run | func (e *EventServer) Run(ctx context.Context) error {
// Create the handler
e.server = &http.Server{
Handler: e,
}
// Start a custom listener
addr, _ := net.ResolveUnixAddr("unix", e.socketPath)
nl, err := net.ListenUnix("unix", addr)
if err != nil {
return fmt.Errorf("Unable to start API server: %s", err)
}
// We make the socket accesible to all users of the system.
// TODO: create a trireme group for this
if err := os.Chmod(addr.String(), 0766); err != nil {
return fmt.Errorf("Cannot make the socket accessible to all users: %s", err)
}
listener := &UIDListener{nl}
// Start serving HTTP requests in the background
go e.server.Serve(listener) // nolint
// Listen for context cancellation to close the socket.
go func() {
<-ctx.Done()
nl.Close() // nolint
}()
return nil
} | go | func (e *EventServer) Run(ctx context.Context) error {
// Create the handler
e.server = &http.Server{
Handler: e,
}
// Start a custom listener
addr, _ := net.ResolveUnixAddr("unix", e.socketPath)
nl, err := net.ListenUnix("unix", addr)
if err != nil {
return fmt.Errorf("Unable to start API server: %s", err)
}
// We make the socket accesible to all users of the system.
// TODO: create a trireme group for this
if err := os.Chmod(addr.String(), 0766); err != nil {
return fmt.Errorf("Cannot make the socket accessible to all users: %s", err)
}
listener := &UIDListener{nl}
// Start serving HTTP requests in the background
go e.server.Serve(listener) // nolint
// Listen for context cancellation to close the socket.
go func() {
<-ctx.Done()
nl.Close() // nolint
}()
return nil
} | [
"func",
"(",
"e",
"*",
"EventServer",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"// Create the handler",
"e",
".",
"server",
"=",
"&",
"http",
".",
"Server",
"{",
"Handler",
":",
"e",
",",
"}",
"\n\n",
"// Start a custom liste... | // Run runs the server. The server will run in the background. It will
// gracefully die with the provided context. | [
"Run",
"runs",
"the",
"server",
".",
"The",
"server",
"will",
"run",
"in",
"the",
"background",
".",
"It",
"will",
"gracefully",
"die",
"with",
"the",
"provided",
"context",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L50-L82 |
7,337 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | create | func (e *EventServer) create(w http.ResponseWriter, r *http.Request) {
event := &common.EventInfo{}
defer r.Body.Close() // nolint
if err := json.NewDecoder(r.Body).Decode(event); err != nil {
http.Error(w, "Invalid request", http.StatusBadRequest)
return
}
if err := validateTypes(event); err != nil {
http.Error(w, fmt.Sprintf("Invalid request fields: %s", err), http.StatusBadRequest)
return
}
if err := validateUser(r, event); err != nil {
http.Error(w, fmt.Sprintf("Invalid user to pid mapping found: %s", err), http.StatusForbidden)
return
}
if err := validateEvent(event); err != nil {
http.Error(w, fmt.Sprintf("Bad request: %s", err), http.StatusBadRequest)
return
}
if err := e.processEvent(r.Context(), event); err != nil {
zap.L().Error("Error in processing event", zap.Error(err), zap.Reflect("Event", event))
http.Error(w, fmt.Sprintf("Cannot handle request: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusAccepted)
} | go | func (e *EventServer) create(w http.ResponseWriter, r *http.Request) {
event := &common.EventInfo{}
defer r.Body.Close() // nolint
if err := json.NewDecoder(r.Body).Decode(event); err != nil {
http.Error(w, "Invalid request", http.StatusBadRequest)
return
}
if err := validateTypes(event); err != nil {
http.Error(w, fmt.Sprintf("Invalid request fields: %s", err), http.StatusBadRequest)
return
}
if err := validateUser(r, event); err != nil {
http.Error(w, fmt.Sprintf("Invalid user to pid mapping found: %s", err), http.StatusForbidden)
return
}
if err := validateEvent(event); err != nil {
http.Error(w, fmt.Sprintf("Bad request: %s", err), http.StatusBadRequest)
return
}
if err := e.processEvent(r.Context(), event); err != nil {
zap.L().Error("Error in processing event", zap.Error(err), zap.Reflect("Event", event))
http.Error(w, fmt.Sprintf("Cannot handle request: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusAccepted)
} | [
"func",
"(",
"e",
"*",
"EventServer",
")",
"create",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"event",
":=",
"&",
"common",
".",
"EventInfo",
"{",
"}",
"\n",
"defer",
"r",
".",
"Body",
".",
"Close",
... | // create is the main hadler that process and validates the events
// before calling the actual monitor handlers to process the event. | [
"create",
"is",
"the",
"main",
"hadler",
"that",
"process",
"and",
"validates",
"the",
"events",
"before",
"calling",
"the",
"actual",
"monitor",
"handlers",
"to",
"process",
"the",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L86-L117 |
7,338 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | processEvent | func (e *EventServer) processEvent(ctx context.Context, eventInfo *common.EventInfo) (err error) {
if e.registerer == nil {
return fmt.Errorf("No registered handlers")
}
f, err := e.registerer.GetHandler(eventInfo.PUType, eventInfo.EventType)
if err != nil {
return fmt.Errorf("Handler not found: %s", err)
}
return f(ctx, eventInfo)
} | go | func (e *EventServer) processEvent(ctx context.Context, eventInfo *common.EventInfo) (err error) {
if e.registerer == nil {
return fmt.Errorf("No registered handlers")
}
f, err := e.registerer.GetHandler(eventInfo.PUType, eventInfo.EventType)
if err != nil {
return fmt.Errorf("Handler not found: %s", err)
}
return f(ctx, eventInfo)
} | [
"func",
"(",
"e",
"*",
"EventServer",
")",
"processEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"eventInfo",
"*",
"common",
".",
"EventInfo",
")",
"(",
"err",
"error",
")",
"{",
"if",
"e",
".",
"registerer",
"==",
"nil",
"{",
"return",
"fmt",
... | // processEvent processes the event by retrieving the right monitor handler. | [
"processEvent",
"processes",
"the",
"event",
"by",
"retrieving",
"the",
"right",
"monitor",
"handler",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L120-L132 |
7,339 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | validateUser | func validateUser(r *http.Request, event *common.EventInfo) error {
// Find the calling user.
parts := strings.Split(r.RemoteAddr, ":")
if len(parts) != 3 {
return fmt.Errorf("Invalid user context")
}
// Accept all requests from root users
if parts[0] == "0" {
return nil
}
// The target process must be valid.
p, err := process.NewProcess(event.PID)
if err != nil {
return fmt.Errorf("Process not found")
}
// The UID of the calling process must match the UID of the target process.
uids, err := p.Uids()
if err != nil {
return fmt.Errorf("Unknown user ID")
}
match := false
for _, uid := range uids {
if strconv.Itoa(int(uid)) == parts[0] {
match = true
}
}
if !match {
return fmt.Errorf("Invalid user - no access to this process: %+v PARTS: %+v", event, parts)
}
return nil
} | go | func validateUser(r *http.Request, event *common.EventInfo) error {
// Find the calling user.
parts := strings.Split(r.RemoteAddr, ":")
if len(parts) != 3 {
return fmt.Errorf("Invalid user context")
}
// Accept all requests from root users
if parts[0] == "0" {
return nil
}
// The target process must be valid.
p, err := process.NewProcess(event.PID)
if err != nil {
return fmt.Errorf("Process not found")
}
// The UID of the calling process must match the UID of the target process.
uids, err := p.Uids()
if err != nil {
return fmt.Errorf("Unknown user ID")
}
match := false
for _, uid := range uids {
if strconv.Itoa(int(uid)) == parts[0] {
match = true
}
}
if !match {
return fmt.Errorf("Invalid user - no access to this process: %+v PARTS: %+v", event, parts)
}
return nil
} | [
"func",
"validateUser",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"event",
"*",
"common",
".",
"EventInfo",
")",
"error",
"{",
"// Find the calling user.",
"parts",
":=",
"strings",
".",
"Split",
"(",
"r",
".",
"RemoteAddr",
",",
"\"",
"\"",
")",
"\n",... | // validateUser validates that the originating user is not sending a request
// for a process that they don't own. Root users are allowed to send
// any event. | [
"validateUser",
"validates",
"that",
"the",
"originating",
"user",
"is",
"not",
"sending",
"a",
"request",
"for",
"a",
"process",
"that",
"they",
"don",
"t",
"own",
".",
"Root",
"users",
"are",
"allowed",
"to",
"send",
"any",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L137-L174 |
7,340 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | validateTypes | func validateTypes(event *common.EventInfo) error {
regexStrings := regexp.MustCompile("^[a-zA-Z0-9_:.$%/-]{0,256}$")
regexNS := regexp.MustCompile("^[a-zA-Z0-9/-]{0,128}$")
regexCgroup := regexp.MustCompile("^/trireme/(uid/){0,1}[a-zA-Z0-9_:.$%]{1,64}$")
if _, ok := common.EventMap[event.EventType]; !ok {
return fmt.Errorf("invalid event: %s", string(event.EventType))
}
if event.PUType > common.TransientPU {
return fmt.Errorf("invalid pu type %v", event.PUType)
}
if !regexStrings.Match([]byte(event.Name)) {
return fmt.Errorf("Name is not of the right format")
}
if len(event.Cgroup) > 0 && !regexCgroup.Match([]byte(event.Cgroup)) {
return fmt.Errorf("Invalid cgroup format: %s", event.Cgroup)
}
if !regexNS.Match([]byte(event.NS)) {
return fmt.Errorf("Namespace is not of the right format")
}
for k, v := range event.IPs {
if !regexStrings.Match([]byte(k)) {
return fmt.Errorf("Invalid IP name: %s", k)
}
if ip := net.ParseIP(v); ip == nil {
return fmt.Errorf("Invalid IP address: %s", v)
}
}
return nil
} | go | func validateTypes(event *common.EventInfo) error {
regexStrings := regexp.MustCompile("^[a-zA-Z0-9_:.$%/-]{0,256}$")
regexNS := regexp.MustCompile("^[a-zA-Z0-9/-]{0,128}$")
regexCgroup := regexp.MustCompile("^/trireme/(uid/){0,1}[a-zA-Z0-9_:.$%]{1,64}$")
if _, ok := common.EventMap[event.EventType]; !ok {
return fmt.Errorf("invalid event: %s", string(event.EventType))
}
if event.PUType > common.TransientPU {
return fmt.Errorf("invalid pu type %v", event.PUType)
}
if !regexStrings.Match([]byte(event.Name)) {
return fmt.Errorf("Name is not of the right format")
}
if len(event.Cgroup) > 0 && !regexCgroup.Match([]byte(event.Cgroup)) {
return fmt.Errorf("Invalid cgroup format: %s", event.Cgroup)
}
if !regexNS.Match([]byte(event.NS)) {
return fmt.Errorf("Namespace is not of the right format")
}
for k, v := range event.IPs {
if !regexStrings.Match([]byte(k)) {
return fmt.Errorf("Invalid IP name: %s", k)
}
if ip := net.ParseIP(v); ip == nil {
return fmt.Errorf("Invalid IP address: %s", v)
}
}
return nil
} | [
"func",
"validateTypes",
"(",
"event",
"*",
"common",
".",
"EventInfo",
")",
"error",
"{",
"regexStrings",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
")",
"\n",
"regexNS",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
")",
"\n",
"regexCg... | // validateTypes validates the various types and prevents any bad strings. | [
"validateTypes",
"validates",
"the",
"various",
"types",
"and",
"prevents",
"any",
"bad",
"strings",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L177-L214 |
7,341 | aporeto-inc/trireme-lib | monitor/remoteapi/server/server.go | validateEvent | func validateEvent(event *common.EventInfo) error {
if event.EventType == common.EventCreate || event.EventType == common.EventStart {
if event.HostService {
if event.NetworkOnlyTraffic {
if event.Name == "" {
return fmt.Errorf("Service name must be provided and must not be default")
}
}
} else {
if event.PUID == "" {
event.PUID = strconv.Itoa(int(event.PID))
}
}
}
if event.EventType == common.EventStop || event.EventType == common.EventDestroy {
regStop := regexp.MustCompile("^/trireme/[a-zA-Z0-9_]{1,11}$")
if event.Cgroup != "" && !regStop.Match([]byte(event.Cgroup)) {
return fmt.Errorf("Cgroup is not of the right format")
}
}
return nil
} | go | func validateEvent(event *common.EventInfo) error {
if event.EventType == common.EventCreate || event.EventType == common.EventStart {
if event.HostService {
if event.NetworkOnlyTraffic {
if event.Name == "" {
return fmt.Errorf("Service name must be provided and must not be default")
}
}
} else {
if event.PUID == "" {
event.PUID = strconv.Itoa(int(event.PID))
}
}
}
if event.EventType == common.EventStop || event.EventType == common.EventDestroy {
regStop := regexp.MustCompile("^/trireme/[a-zA-Z0-9_]{1,11}$")
if event.Cgroup != "" && !regStop.Match([]byte(event.Cgroup)) {
return fmt.Errorf("Cgroup is not of the right format")
}
}
return nil
} | [
"func",
"validateEvent",
"(",
"event",
"*",
"common",
".",
"EventInfo",
")",
"error",
"{",
"if",
"event",
".",
"EventType",
"==",
"common",
".",
"EventCreate",
"||",
"event",
".",
"EventType",
"==",
"common",
".",
"EventStart",
"{",
"if",
"event",
".",
"... | // validateEvent validates that this is reasonable event and
// modifies the default values. | [
"validateEvent",
"validates",
"that",
"this",
"is",
"reasonable",
"event",
"and",
"modifies",
"the",
"default",
"values",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/remoteapi/server/server.go#L218-L242 |
7,342 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/portset.go | createPortSet | func (i *Instance) createPortSet(contextID string, puInfo *policy.PUInfo) error {
if i.mode == constants.RemoteContainer {
return nil
}
username := puInfo.Runtime.Options().UserID
prefix := ""
if username != "" {
prefix = uidPortSetPrefix
} else {
prefix = processPortSetPrefix
}
portSetName := puPortSetName(contextID, prefix)
if puseterr := i.createPUPortSet(portSetName); puseterr != nil {
return puseterr
}
i.contextIDToPortSetMap.AddOrUpdate(contextID, portSetName)
return nil
} | go | func (i *Instance) createPortSet(contextID string, puInfo *policy.PUInfo) error {
if i.mode == constants.RemoteContainer {
return nil
}
username := puInfo.Runtime.Options().UserID
prefix := ""
if username != "" {
prefix = uidPortSetPrefix
} else {
prefix = processPortSetPrefix
}
portSetName := puPortSetName(contextID, prefix)
if puseterr := i.createPUPortSet(portSetName); puseterr != nil {
return puseterr
}
i.contextIDToPortSetMap.AddOrUpdate(contextID, portSetName)
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"createPortSet",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"if",
"i",
".",
"mode",
"==",
"constants",
".",
"RemoteContainer",
"{",
"return",
"nil",
"\n",
"}",
"\n... | // createPortSets creates either UID or process port sets. This is only
// needed for Linux PUs and it returns immediately for container PUs. | [
"createPortSets",
"creates",
"either",
"UID",
"or",
"process",
"port",
"sets",
".",
"This",
"is",
"only",
"needed",
"for",
"Linux",
"PUs",
"and",
"it",
"returns",
"immediately",
"for",
"container",
"PUs",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/portset.go#L24-L47 |
7,343 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/portset.go | deletePortSet | func (i *Instance) deletePortSet(contextID string) error {
if i.mode == constants.RemoteContainer {
return nil
}
portSetName := i.getPortSet(contextID)
if portSetName == "" {
return fmt.Errorf("Failed to find port set")
}
ips := ipset.IPSet{
Name: portSetName,
}
if err := ips.Destroy(); err != nil {
return fmt.Errorf("Failed to delete pu port set "+portSetName, zap.Error(err))
}
if err := i.contextIDToPortSetMap.Remove(contextID); err != nil {
zap.L().Debug("portset not found for the contextID", zap.String("contextID", contextID))
}
return nil
} | go | func (i *Instance) deletePortSet(contextID string) error {
if i.mode == constants.RemoteContainer {
return nil
}
portSetName := i.getPortSet(contextID)
if portSetName == "" {
return fmt.Errorf("Failed to find port set")
}
ips := ipset.IPSet{
Name: portSetName,
}
if err := ips.Destroy(); err != nil {
return fmt.Errorf("Failed to delete pu port set "+portSetName, zap.Error(err))
}
if err := i.contextIDToPortSetMap.Remove(contextID); err != nil {
zap.L().Debug("portset not found for the contextID", zap.String("contextID", contextID))
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"deletePortSet",
"(",
"contextID",
"string",
")",
"error",
"{",
"if",
"i",
".",
"mode",
"==",
"constants",
".",
"RemoteContainer",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"portSetName",
":=",
"i",
".",
"getPortSet... | // deletePortSet delets the ports set that was created for a Linux PU.
// It returns without errors for container PUs. | [
"deletePortSet",
"delets",
"the",
"ports",
"set",
"that",
"was",
"created",
"for",
"a",
"Linux",
"PU",
".",
"It",
"returns",
"without",
"errors",
"for",
"container",
"PUs",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/portset.go#L51-L75 |
7,344 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/portset.go | DeletePortFromPortSet | func (i *Instance) DeletePortFromPortSet(contextID string, port string) error {
portSetName := i.getPortSet(contextID)
if portSetName == "" {
return fmt.Errorf("unable to get portset for contextID %s", contextID)
}
ips := ipset.IPSet{
Name: portSetName,
}
if _, err := strconv.Atoi(port); err != nil {
return fmt.Errorf("invalid port: %s", err)
}
if err := ips.Del(port); err != nil {
return fmt.Errorf("unable to delete port from portset: %s", err)
}
return nil
} | go | func (i *Instance) DeletePortFromPortSet(contextID string, port string) error {
portSetName := i.getPortSet(contextID)
if portSetName == "" {
return fmt.Errorf("unable to get portset for contextID %s", contextID)
}
ips := ipset.IPSet{
Name: portSetName,
}
if _, err := strconv.Atoi(port); err != nil {
return fmt.Errorf("invalid port: %s", err)
}
if err := ips.Del(port); err != nil {
return fmt.Errorf("unable to delete port from portset: %s", err)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"DeletePortFromPortSet",
"(",
"contextID",
"string",
",",
"port",
"string",
")",
"error",
"{",
"portSetName",
":=",
"i",
".",
"getPortSet",
"(",
"contextID",
")",
"\n",
"if",
"portSetName",
"==",
"\"",
"\"",
"{",
"... | // DeletePortFromPortSet deletes ports from port sets | [
"DeletePortFromPortSet",
"deletes",
"ports",
"from",
"port",
"sets"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/portset.go#L78-L97 |
7,345 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/collector.go | NewCollector | func NewCollector() Collector {
return &collectorImpl{
Flows: map[string]*collector.FlowRecord{},
Users: map[string]*collector.UserRecord{},
ProcessedUsers: map[string]bool{},
DatapathPacketReports: []*collector.PacketReport{},
}
} | go | func NewCollector() Collector {
return &collectorImpl{
Flows: map[string]*collector.FlowRecord{},
Users: map[string]*collector.UserRecord{},
ProcessedUsers: map[string]bool{},
DatapathPacketReports: []*collector.PacketReport{},
}
} | [
"func",
"NewCollector",
"(",
")",
"Collector",
"{",
"return",
"&",
"collectorImpl",
"{",
"Flows",
":",
"map",
"[",
"string",
"]",
"*",
"collector",
".",
"FlowRecord",
"{",
"}",
",",
"Users",
":",
"map",
"[",
"string",
"]",
"*",
"collector",
".",
"UserR... | // NewCollector provides a new collector interface | [
"NewCollector",
"provides",
"a",
"new",
"collector",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/collector.go#L10-L17 |
7,346 | aporeto-inc/trireme-lib | monitor/extractors/docker.go | DefaultMetadataExtractor | func DefaultMetadataExtractor(info *types.ContainerJSON) (*policy.PURuntime, error) {
// trigger new build
tags := policy.NewTagStore()
// TODO: Remove OLDTAGS
tags.AppendKeyValue("@sys:image", info.Config.Image)
tags.AppendKeyValue("@sys:name", info.Name)
tags.AppendKeyValue("@app:image", info.Config.Image)
tags.AppendKeyValue("@app:extractor", "docker")
tags.AppendKeyValue("@app:docker:name", info.Name)
for k, v := range info.Config.Labels {
if len(strings.TrimSpace(k)) == 0 {
continue
}
value := v
if len(v) == 0 {
value = "<empty>"
}
if !strings.HasPrefix(k, UserLabelPrefix) {
tags.AppendKeyValue(UserLabelPrefix+k, value)
} else {
tags.AppendKeyValue(k, value)
}
}
ipa := policy.ExtendedMap{
"bridge": info.NetworkSettings.IPAddress,
}
if info.HostConfig.NetworkMode == constants.DockerHostMode {
return policy.NewPURuntime(info.Name, info.State.Pid, "", tags, ipa, common.LinuxProcessPU, hostModeOptions(info)), nil
}
return policy.NewPURuntime(info.Name, info.State.Pid, "", tags, ipa, common.ContainerPU, nil), nil
} | go | func DefaultMetadataExtractor(info *types.ContainerJSON) (*policy.PURuntime, error) {
// trigger new build
tags := policy.NewTagStore()
// TODO: Remove OLDTAGS
tags.AppendKeyValue("@sys:image", info.Config.Image)
tags.AppendKeyValue("@sys:name", info.Name)
tags.AppendKeyValue("@app:image", info.Config.Image)
tags.AppendKeyValue("@app:extractor", "docker")
tags.AppendKeyValue("@app:docker:name", info.Name)
for k, v := range info.Config.Labels {
if len(strings.TrimSpace(k)) == 0 {
continue
}
value := v
if len(v) == 0 {
value = "<empty>"
}
if !strings.HasPrefix(k, UserLabelPrefix) {
tags.AppendKeyValue(UserLabelPrefix+k, value)
} else {
tags.AppendKeyValue(k, value)
}
}
ipa := policy.ExtendedMap{
"bridge": info.NetworkSettings.IPAddress,
}
if info.HostConfig.NetworkMode == constants.DockerHostMode {
return policy.NewPURuntime(info.Name, info.State.Pid, "", tags, ipa, common.LinuxProcessPU, hostModeOptions(info)), nil
}
return policy.NewPURuntime(info.Name, info.State.Pid, "", tags, ipa, common.ContainerPU, nil), nil
} | [
"func",
"DefaultMetadataExtractor",
"(",
"info",
"*",
"types",
".",
"ContainerJSON",
")",
"(",
"*",
"policy",
".",
"PURuntime",
",",
"error",
")",
"{",
"// trigger new build",
"tags",
":=",
"policy",
".",
"NewTagStore",
"(",
")",
"\n",
"// TODO: Remove OLDTAGS",... | // DefaultMetadataExtractor is the default metadata extractor for Docker | [
"DefaultMetadataExtractor",
"is",
"the",
"default",
"metadata",
"extractor",
"for",
"Docker"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/docker.go#L25-L60 |
7,347 | aporeto-inc/trireme-lib | monitor/extractors/docker.go | hostModeOptions | func hostModeOptions(dockerInfo *types.ContainerJSON) *policy.OptionsType {
options := policy.OptionsType{
CgroupName: strconv.Itoa(dockerInfo.State.Pid),
CgroupMark: strconv.FormatUint(cgnetcls.MarkVal(), 10),
}
for p := range dockerInfo.Config.ExposedPorts {
if p.Proto() == "tcp" {
s, err := portspec.NewPortSpecFromString(p.Port(), nil)
if err != nil {
continue
}
options.Services = append(options.Services, common.Service{
Protocol: uint8(6),
Ports: s,
})
}
}
return &options
} | go | func hostModeOptions(dockerInfo *types.ContainerJSON) *policy.OptionsType {
options := policy.OptionsType{
CgroupName: strconv.Itoa(dockerInfo.State.Pid),
CgroupMark: strconv.FormatUint(cgnetcls.MarkVal(), 10),
}
for p := range dockerInfo.Config.ExposedPorts {
if p.Proto() == "tcp" {
s, err := portspec.NewPortSpecFromString(p.Port(), nil)
if err != nil {
continue
}
options.Services = append(options.Services, common.Service{
Protocol: uint8(6),
Ports: s,
})
}
}
return &options
} | [
"func",
"hostModeOptions",
"(",
"dockerInfo",
"*",
"types",
".",
"ContainerJSON",
")",
"*",
"policy",
".",
"OptionsType",
"{",
"options",
":=",
"policy",
".",
"OptionsType",
"{",
"CgroupName",
":",
"strconv",
".",
"Itoa",
"(",
"dockerInfo",
".",
"State",
"."... | // hostModeOptions creates the default options for a host-mode container. This is done
// based on the policy and the metadata extractor logic and can very by implementation | [
"hostModeOptions",
"creates",
"the",
"default",
"options",
"for",
"a",
"host",
"-",
"mode",
"container",
".",
"This",
"is",
"done",
"based",
"on",
"the",
"policy",
"and",
"the",
"metadata",
"extractor",
"logic",
"and",
"can",
"very",
"by",
"implementation"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/docker.go#L64-L86 |
7,348 | aporeto-inc/trireme-lib | collector/default.go | StatsFlowHash | func StatsFlowHash(r *FlowRecord) string {
hash := xxhash.New()
hash.Write([]byte(r.Source.ID)) // nolint errcheck
hash.Write([]byte(r.Destination.ID)) // nolint errcheck
port := make([]byte, 2)
binary.BigEndian.PutUint16(port, r.Destination.Port)
hash.Write(port) // nolint errcheck
hash.Write([]byte(r.Action.String())) // nolint errcheck
hash.Write([]byte(r.ObservedAction.String())) // nolint errcheck
hash.Write([]byte(r.DropReason)) // nolint errcheck
hash.Write([]byte(r.Destination.URI)) // nolint errcheck
return fmt.Sprintf("%d", hash.Sum64())
} | go | func StatsFlowHash(r *FlowRecord) string {
hash := xxhash.New()
hash.Write([]byte(r.Source.ID)) // nolint errcheck
hash.Write([]byte(r.Destination.ID)) // nolint errcheck
port := make([]byte, 2)
binary.BigEndian.PutUint16(port, r.Destination.Port)
hash.Write(port) // nolint errcheck
hash.Write([]byte(r.Action.String())) // nolint errcheck
hash.Write([]byte(r.ObservedAction.String())) // nolint errcheck
hash.Write([]byte(r.DropReason)) // nolint errcheck
hash.Write([]byte(r.Destination.URI)) // nolint errcheck
return fmt.Sprintf("%d", hash.Sum64())
} | [
"func",
"StatsFlowHash",
"(",
"r",
"*",
"FlowRecord",
")",
"string",
"{",
"hash",
":=",
"xxhash",
".",
"New",
"(",
")",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"Source",
".",
"ID",
")",
")",
"// nolint errcheck",
"\n",
"ha... | // StatsFlowHash is a hash function to hash flows | [
"StatsFlowHash",
"is",
"a",
"hash",
"function",
"to",
"hash",
"flows"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/collector/default.go#L36-L49 |
7,349 | aporeto-inc/trireme-lib | collector/default.go | StatsUserHash | func StatsUserHash(r *UserRecord) error {
// Order matters for the hash function loop
sort.Strings(r.Claims)
hash := xxhash.New()
for i := 0; i < len(r.Claims); i++ {
if strings.HasPrefix(r.Claims[i], "sub") {
continue
}
if _, err := hash.Write([]byte(r.Claims[i])); err != nil {
return fmt.Errorf("Cannot create hash")
}
}
r.ID = fmt.Sprintf("%d", hash.Sum64())
return nil
} | go | func StatsUserHash(r *UserRecord) error {
// Order matters for the hash function loop
sort.Strings(r.Claims)
hash := xxhash.New()
for i := 0; i < len(r.Claims); i++ {
if strings.HasPrefix(r.Claims[i], "sub") {
continue
}
if _, err := hash.Write([]byte(r.Claims[i])); err != nil {
return fmt.Errorf("Cannot create hash")
}
}
r.ID = fmt.Sprintf("%d", hash.Sum64())
return nil
} | [
"func",
"StatsUserHash",
"(",
"r",
"*",
"UserRecord",
")",
"error",
"{",
"// Order matters for the hash function loop",
"sort",
".",
"Strings",
"(",
"r",
".",
"Claims",
")",
"\n",
"hash",
":=",
"xxhash",
".",
"New",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
... | // StatsUserHash is a hash function to hash user records | [
"StatsUserHash",
"is",
"a",
"hash",
"function",
"to",
"hash",
"user",
"records"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/collector/default.go#L52-L67 |
7,350 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | NewPortCache | func NewPortCache(name string) *PortCache {
return &PortCache{
ports: cache.NewCache(name),
ranges: []*portspec.PortSpec{},
}
} | go | func NewPortCache(name string) *PortCache {
return &PortCache{
ports: cache.NewCache(name),
ranges: []*portspec.PortSpec{},
}
} | [
"func",
"NewPortCache",
"(",
"name",
"string",
")",
"*",
"PortCache",
"{",
"return",
"&",
"PortCache",
"{",
"ports",
":",
"cache",
".",
"NewCache",
"(",
"name",
")",
",",
"ranges",
":",
"[",
"]",
"*",
"portspec",
".",
"PortSpec",
"{",
"}",
",",
"}",
... | // NewPortCache creates a new port cache | [
"NewPortCache",
"creates",
"a",
"new",
"port",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L21-L26 |
7,351 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | AddPortSpec | func (p *PortCache) AddPortSpec(s *portspec.PortSpec) {
if s.Min == s.Max {
p.ports.AddOrUpdate(s.Min, s)
} else {
// Remove the range if it exists
p.Remove(s) // nolint
// Insert the portspec
p.Lock()
p.ranges = append([]*portspec.PortSpec{s}, p.ranges...)
p.Unlock()
}
} | go | func (p *PortCache) AddPortSpec(s *portspec.PortSpec) {
if s.Min == s.Max {
p.ports.AddOrUpdate(s.Min, s)
} else {
// Remove the range if it exists
p.Remove(s) // nolint
// Insert the portspec
p.Lock()
p.ranges = append([]*portspec.PortSpec{s}, p.ranges...)
p.Unlock()
}
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"AddPortSpec",
"(",
"s",
"*",
"portspec",
".",
"PortSpec",
")",
"{",
"if",
"s",
".",
"Min",
"==",
"s",
".",
"Max",
"{",
"p",
".",
"ports",
".",
"AddOrUpdate",
"(",
"s",
".",
"Min",
",",
"s",
")",
"\n",
... | // AddPortSpec adds a port spec into the cache | [
"AddPortSpec",
"adds",
"a",
"port",
"spec",
"into",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L29-L40 |
7,352 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | AddPortSpecToEnd | func (p *PortCache) AddPortSpecToEnd(s *portspec.PortSpec) {
// Remove the range if it exists
p.Remove(s) // nolint
p.Lock()
p.ranges = append(p.ranges, s)
p.Unlock()
} | go | func (p *PortCache) AddPortSpecToEnd(s *portspec.PortSpec) {
// Remove the range if it exists
p.Remove(s) // nolint
p.Lock()
p.ranges = append(p.ranges, s)
p.Unlock()
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"AddPortSpecToEnd",
"(",
"s",
"*",
"portspec",
".",
"PortSpec",
")",
"{",
"// Remove the range if it exists",
"p",
".",
"Remove",
"(",
"s",
")",
"// nolint",
"\n\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"p",
".",
"... | // AddPortSpecToEnd adds a range at the end of the cache | [
"AddPortSpecToEnd",
"adds",
"a",
"range",
"at",
"the",
"end",
"of",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L43-L52 |
7,353 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | AddUnique | func (p *PortCache) AddUnique(s *portspec.PortSpec) error {
p.Lock()
defer p.Unlock()
if s.Min == s.Max {
if err, _ := p.ports.Get(s.Min); err != nil {
return fmt.Errorf("Port already exists: %s", err)
}
}
for _, r := range p.ranges {
if r.Max <= s.Min || r.Min >= s.Max {
continue
}
return fmt.Errorf("Overlap detected: %d %d", r.Max, r.Min)
}
if s.Min == s.Max {
return p.ports.Add(s.Min, s)
}
p.ranges = append(p.ranges, s)
return nil
} | go | func (p *PortCache) AddUnique(s *portspec.PortSpec) error {
p.Lock()
defer p.Unlock()
if s.Min == s.Max {
if err, _ := p.ports.Get(s.Min); err != nil {
return fmt.Errorf("Port already exists: %s", err)
}
}
for _, r := range p.ranges {
if r.Max <= s.Min || r.Min >= s.Max {
continue
}
return fmt.Errorf("Overlap detected: %d %d", r.Max, r.Min)
}
if s.Min == s.Max {
return p.ports.Add(s.Min, s)
}
p.ranges = append(p.ranges, s)
return nil
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"AddUnique",
"(",
"s",
"*",
"portspec",
".",
"PortSpec",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"Min",
"==",
"s",
".",
"Max",
... | // AddUnique adds a port spec into the cache and makes sure its unique | [
"AddUnique",
"adds",
"a",
"port",
"spec",
"into",
"the",
"cache",
"and",
"makes",
"sure",
"its",
"unique"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L55-L78 |
7,354 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | GetSpecValueFromPort | func (p *PortCache) GetSpecValueFromPort(port uint16) (interface{}, error) {
if spec, err := p.ports.Get(port); err == nil {
return spec.(*portspec.PortSpec).Value(), nil
}
p.Lock()
defer p.Unlock()
for _, s := range p.ranges {
if s.Min <= port && port < s.Max {
return s.Value(), nil
}
}
return nil, fmt.Errorf("No match for port %d", port)
} | go | func (p *PortCache) GetSpecValueFromPort(port uint16) (interface{}, error) {
if spec, err := p.ports.Get(port); err == nil {
return spec.(*portspec.PortSpec).Value(), nil
}
p.Lock()
defer p.Unlock()
for _, s := range p.ranges {
if s.Min <= port && port < s.Max {
return s.Value(), nil
}
}
return nil, fmt.Errorf("No match for port %d", port)
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"GetSpecValueFromPort",
"(",
"port",
"uint16",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"spec",
",",
"err",
":=",
"p",
".",
"ports",
".",
"Get",
"(",
"port",
")",
";",
"err",
"==",
"n... | // GetSpecValueFromPort searches the cache for a match based on a port
// It will return the first match found on exact ports or on the ranges
// of ports. If there are multiple intervals that match it will randomly
// return one of them. | [
"GetSpecValueFromPort",
"searches",
"the",
"cache",
"for",
"a",
"match",
"based",
"on",
"a",
"port",
"It",
"will",
"return",
"the",
"first",
"match",
"found",
"on",
"exact",
"ports",
"or",
"on",
"the",
"ranges",
"of",
"ports",
".",
"If",
"there",
"are",
... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L84-L98 |
7,355 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | Remove | func (p *PortCache) Remove(s *portspec.PortSpec) error {
if s.Min == s.Max {
return p.ports.Remove(s.Min)
}
p.Lock()
defer p.Unlock()
for i, r := range p.ranges {
if r.Min == s.Min && r.Max == s.Max {
left := p.ranges[:i]
right := p.ranges[i+1:]
p.ranges = append(left, right...)
return nil
}
}
return fmt.Errorf("port not found")
} | go | func (p *PortCache) Remove(s *portspec.PortSpec) error {
if s.Min == s.Max {
return p.ports.Remove(s.Min)
}
p.Lock()
defer p.Unlock()
for i, r := range p.ranges {
if r.Min == s.Min && r.Max == s.Max {
left := p.ranges[:i]
right := p.ranges[i+1:]
p.ranges = append(left, right...)
return nil
}
}
return fmt.Errorf("port not found")
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"Remove",
"(",
"s",
"*",
"portspec",
".",
"PortSpec",
")",
"error",
"{",
"if",
"s",
".",
"Min",
"==",
"s",
".",
"Max",
"{",
"return",
"p",
".",
"ports",
".",
"Remove",
"(",
"s",
".",
"Min",
")",
"\n",
... | // Remove will remove a port from the cache | [
"Remove",
"will",
"remove",
"a",
"port",
"from",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L124-L142 |
7,356 | aporeto-inc/trireme-lib | utils/portcache/portcache.go | RemoveStringPorts | func (p *PortCache) RemoveStringPorts(ports string) error {
s, err := portspec.NewPortSpecFromString(ports, nil)
if err != nil {
return err
}
return p.Remove(s)
} | go | func (p *PortCache) RemoveStringPorts(ports string) error {
s, err := portspec.NewPortSpecFromString(ports, nil)
if err != nil {
return err
}
return p.Remove(s)
} | [
"func",
"(",
"p",
"*",
"PortCache",
")",
"RemoveStringPorts",
"(",
"ports",
"string",
")",
"error",
"{",
"s",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"ports",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err... | // RemoveStringPorts will remove a port from the cache | [
"RemoveStringPorts",
"will",
"remove",
"a",
"port",
"from",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portcache/portcache.go#L145-L153 |
7,357 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go | NewMockRemoteIntf | func NewMockRemoteIntf(ctrl *gomock.Controller) *MockRemoteIntf {
mock := &MockRemoteIntf{ctrl: ctrl}
mock.recorder = &MockRemoteIntfMockRecorder{mock}
return mock
} | go | func NewMockRemoteIntf(ctrl *gomock.Controller) *MockRemoteIntf {
mock := &MockRemoteIntf{ctrl: ctrl}
mock.recorder = &MockRemoteIntfMockRecorder{mock}
return mock
} | [
"func",
"NewMockRemoteIntf",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRemoteIntf",
"{",
"mock",
":=",
"&",
"MockRemoteIntf",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRemoteIntfMockRecorder",
"{",
"mock... | // NewMockRemoteIntf creates a new mock instance
// nolint | [
"NewMockRemoteIntf",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go#L29-L33 |
7,358 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go | InitEnforcer | func (m *MockRemoteIntf) InitEnforcer(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
ret := m.ctrl.Call(m, "InitEnforcer", req, resp)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRemoteIntf) InitEnforcer(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
ret := m.ctrl.Call(m, "InitEnforcer", req, resp)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRemoteIntf",
")",
"InitEnforcer",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
... | // InitEnforcer mocks base method
// nolint | [
"InitEnforcer",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go#L43-L47 |
7,359 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go | InitEnforcer | func (mr *MockRemoteIntfMockRecorder) InitEnforcer(req, resp interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitEnforcer", reflect.TypeOf((*MockRemoteIntf)(nil).InitEnforcer), req, resp)
} | go | func (mr *MockRemoteIntfMockRecorder) InitEnforcer(req, resp interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitEnforcer", reflect.TypeOf((*MockRemoteIntf)(nil).InitEnforcer), req, resp)
} | [
"func",
"(",
"mr",
"*",
"MockRemoteIntfMockRecorder",
")",
"InitEnforcer",
"(",
"req",
",",
"resp",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"m... | // InitEnforcer indicates an expected call of InitEnforcer
// nolint | [
"InitEnforcer",
"indicates",
"an",
"expected",
"call",
"of",
"InitEnforcer",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/mockremoteenforcer/mockremoteenforcer.go#L51-L53 |
7,360 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | Run | func (e *enforcer) Run(ctx context.Context) error {
if e.proxy != nil {
if err := e.proxy.Run(ctx); err != nil {
return err
}
}
if e.transport != nil {
if err := e.transport.Run(ctx); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.Run(ctx); err != nil {
return err
}
}
return nil
} | go | func (e *enforcer) Run(ctx context.Context) error {
if e.proxy != nil {
if err := e.proxy.Run(ctx); err != nil {
return err
}
}
if e.transport != nil {
if err := e.transport.Run(ctx); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.Run(ctx); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"enforcer",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"e",
".",
"proxy",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"proxy",
".",
"Run",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{... | // Run implements the run interfaces and runs the individual data paths | [
"Run",
"implements",
"the",
"run",
"interfaces",
"and",
"runs",
"the",
"individual",
"data",
"paths"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L69-L90 |
7,361 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | Enforce | func (e *enforcer) Enforce(contextID string, puInfo *policy.PUInfo) error {
if e.transport != nil {
if err := e.transport.Enforce(contextID, puInfo); err != nil {
return fmt.Errorf("unable to enforce in nfq: %s", err)
}
}
if e.proxy != nil {
if err := e.proxy.Enforce(context.Background(), contextID, puInfo); err != nil {
return fmt.Errorf("unable to enforce in proxy: %s", err)
}
}
if e.secrets != nil {
if err := e.secrets.Enforce(puInfo); err != nil {
return fmt.Errorf("unable to enforce in secrets proxy: %s", err)
}
}
return nil
} | go | func (e *enforcer) Enforce(contextID string, puInfo *policy.PUInfo) error {
if e.transport != nil {
if err := e.transport.Enforce(contextID, puInfo); err != nil {
return fmt.Errorf("unable to enforce in nfq: %s", err)
}
}
if e.proxy != nil {
if err := e.proxy.Enforce(context.Background(), contextID, puInfo); err != nil {
return fmt.Errorf("unable to enforce in proxy: %s", err)
}
}
if e.secrets != nil {
if err := e.secrets.Enforce(puInfo); err != nil {
return fmt.Errorf("unable to enforce in secrets proxy: %s", err)
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"enforcer",
")",
"Enforce",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"if",
"e",
".",
"transport",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"transport",
".",
"Enforce",
... | // Enforce implements the enforce interface by sending the event to all the enforcers. | [
"Enforce",
"implements",
"the",
"enforce",
"interface",
"by",
"sending",
"the",
"event",
"to",
"all",
"the",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L93-L114 |
7,362 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | Unenforce | func (e *enforcer) Unenforce(contextID string) error {
var perr, nerr, serr error
if e.proxy != nil {
if perr = e.proxy.Unenforce(context.Background(), contextID); perr != nil {
zap.L().Error("Failed to unenforce contextID in proxy",
zap.String("ContextID", contextID),
zap.Error(perr),
)
}
}
if e.transport != nil {
if nerr = e.transport.Unenforce(contextID); nerr != nil {
zap.L().Error("Failed to unenforce contextID in transport",
zap.String("ContextID", contextID),
zap.Error(nerr),
)
}
}
if e.secrets != nil {
if serr = e.secrets.Unenforce(contextID); nerr != nil {
zap.L().Error("Failed to unenforce contextID in transport",
zap.String("ContextID", contextID),
zap.Error(nerr),
)
}
}
if perr != nil || nerr != nil || serr != nil {
return fmt.Errorf("Failed to unenforce %s %s", perr, nerr)
}
return nil
} | go | func (e *enforcer) Unenforce(contextID string) error {
var perr, nerr, serr error
if e.proxy != nil {
if perr = e.proxy.Unenforce(context.Background(), contextID); perr != nil {
zap.L().Error("Failed to unenforce contextID in proxy",
zap.String("ContextID", contextID),
zap.Error(perr),
)
}
}
if e.transport != nil {
if nerr = e.transport.Unenforce(contextID); nerr != nil {
zap.L().Error("Failed to unenforce contextID in transport",
zap.String("ContextID", contextID),
zap.Error(nerr),
)
}
}
if e.secrets != nil {
if serr = e.secrets.Unenforce(contextID); nerr != nil {
zap.L().Error("Failed to unenforce contextID in transport",
zap.String("ContextID", contextID),
zap.Error(nerr),
)
}
}
if perr != nil || nerr != nil || serr != nil {
return fmt.Errorf("Failed to unenforce %s %s", perr, nerr)
}
return nil
} | [
"func",
"(",
"e",
"*",
"enforcer",
")",
"Unenforce",
"(",
"contextID",
"string",
")",
"error",
"{",
"var",
"perr",
",",
"nerr",
",",
"serr",
"error",
"\n",
"if",
"e",
".",
"proxy",
"!=",
"nil",
"{",
"if",
"perr",
"=",
"e",
".",
"proxy",
".",
"Une... | // Unenforce implements the Unenforce interface by sending the event to all the enforcers. | [
"Unenforce",
"implements",
"the",
"Unenforce",
"interface",
"by",
"sending",
"the",
"event",
"to",
"all",
"the",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L117-L152 |
7,363 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | UpdateSecrets | func (e *enforcer) UpdateSecrets(secrets secrets.Secrets) error {
if e.proxy != nil {
if err := e.proxy.UpdateSecrets(secrets); err != nil {
return err
}
}
if e.transport != nil {
if err := e.transport.UpdateSecrets(secrets); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.UpdateSecrets(secrets); err != nil {
return err
}
}
return nil
} | go | func (e *enforcer) UpdateSecrets(secrets secrets.Secrets) error {
if e.proxy != nil {
if err := e.proxy.UpdateSecrets(secrets); err != nil {
return err
}
}
if e.transport != nil {
if err := e.transport.UpdateSecrets(secrets); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.UpdateSecrets(secrets); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"enforcer",
")",
"UpdateSecrets",
"(",
"secrets",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"if",
"e",
".",
"proxy",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"proxy",
".",
"UpdateSecrets",
"(",
"secrets",
")",
";",
... | // Updatesecrets updates the secrets of the enforcers | [
"Updatesecrets",
"updates",
"the",
"secrets",
"of",
"the",
"enforcers"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L159-L179 |
7,364 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | EnableDatapathPacketTracing | func (e *enforcer) EnableDatapathPacketTracing(contextID string, direction packettracing.TracingDirection, interval time.Duration) error {
return e.transport.EnableDatapathPacketTracing(contextID, direction, interval)
} | go | func (e *enforcer) EnableDatapathPacketTracing(contextID string, direction packettracing.TracingDirection, interval time.Duration) error {
return e.transport.EnableDatapathPacketTracing(contextID, direction, interval)
} | [
"func",
"(",
"e",
"*",
"enforcer",
")",
"EnableDatapathPacketTracing",
"(",
"contextID",
"string",
",",
"direction",
"packettracing",
".",
"TracingDirection",
",",
"interval",
"time",
".",
"Duration",
")",
"error",
"{",
"return",
"e",
".",
"transport",
".",
"E... | // EnableDatapathPacketTracing implemented the datapath packet tracing | [
"EnableDatapathPacketTracing",
"implemented",
"the",
"datapath",
"packet",
"tracing"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L192-L195 |
7,365 | aporeto-inc/trireme-lib | controller/internal/enforcer/enforcer.go | New | func New(
mutualAuthorization bool,
fqConfig *fqconfig.FilterQueue,
collector collector.EventCollector,
service packetprocessor.PacketProcessor,
secrets secrets.Secrets,
serverID string,
validity time.Duration,
mode constants.ModeType,
procMountPoint string,
externalIPCacheTimeout time.Duration,
packetLogs bool,
cfg *runtime.Configuration,
) (Enforcer, error) {
tokenAccessor, err := tokenaccessor.New(serverID, validity, secrets)
if err != nil {
zap.L().Fatal("Cannot create a token engine")
}
puFromContextID := cache.NewCache("puFromContextID")
transport := nfqdatapath.New(
mutualAuthorization,
fqConfig,
collector,
serverID,
validity,
service,
secrets,
mode,
procMountPoint,
externalIPCacheTimeout,
packetLogs,
tokenAccessor,
puFromContextID,
cfg,
)
tcpProxy, err := applicationproxy.NewAppProxy(tokenAccessor, collector, puFromContextID, nil, secrets)
if err != nil {
return nil, err
}
return &enforcer{
proxy: tcpProxy,
transport: transport,
secrets: secretsproxy.NewSecretsProxy(),
}, nil
} | go | func New(
mutualAuthorization bool,
fqConfig *fqconfig.FilterQueue,
collector collector.EventCollector,
service packetprocessor.PacketProcessor,
secrets secrets.Secrets,
serverID string,
validity time.Duration,
mode constants.ModeType,
procMountPoint string,
externalIPCacheTimeout time.Duration,
packetLogs bool,
cfg *runtime.Configuration,
) (Enforcer, error) {
tokenAccessor, err := tokenaccessor.New(serverID, validity, secrets)
if err != nil {
zap.L().Fatal("Cannot create a token engine")
}
puFromContextID := cache.NewCache("puFromContextID")
transport := nfqdatapath.New(
mutualAuthorization,
fqConfig,
collector,
serverID,
validity,
service,
secrets,
mode,
procMountPoint,
externalIPCacheTimeout,
packetLogs,
tokenAccessor,
puFromContextID,
cfg,
)
tcpProxy, err := applicationproxy.NewAppProxy(tokenAccessor, collector, puFromContextID, nil, secrets)
if err != nil {
return nil, err
}
return &enforcer{
proxy: tcpProxy,
transport: transport,
secrets: secretsproxy.NewSecretsProxy(),
}, nil
} | [
"func",
"New",
"(",
"mutualAuthorization",
"bool",
",",
"fqConfig",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"collector",
"collector",
".",
"EventCollector",
",",
"service",
"packetprocessor",
".",
"PacketProcessor",
",",
"secrets",
"secrets",
".",
"Secrets",
","... | // New returns a new policy enforcer that implements both the data paths. | [
"New",
"returns",
"a",
"new",
"policy",
"enforcer",
"that",
"implements",
"both",
"the",
"data",
"paths",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/enforcer.go#L203-L252 |
7,366 | aporeto-inc/trireme-lib | controller/pkg/claimsheader/bytes.go | extractHeaderAttribute | func (h HeaderBytes) extractHeaderAttribute(mask uint32) uint32 {
data := binary.LittleEndian.Uint32(h)
return data & mask
} | go | func (h HeaderBytes) extractHeaderAttribute(mask uint32) uint32 {
data := binary.LittleEndian.Uint32(h)
return data & mask
} | [
"func",
"(",
"h",
"HeaderBytes",
")",
"extractHeaderAttribute",
"(",
"mask",
"uint32",
")",
"uint32",
"{",
"data",
":=",
"binary",
".",
"LittleEndian",
".",
"Uint32",
"(",
"h",
")",
"\n\n",
"return",
"data",
"&",
"mask",
"\n",
"}"
] | // extractHeaderAttribute returns the attribute from bytes
// mask - mask specific to the attribute | [
"extractHeaderAttribute",
"returns",
"the",
"attribute",
"from",
"bytes",
"mask",
"-",
"mask",
"specific",
"to",
"the",
"attribute"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/bytes.go#L26-L31 |
7,367 | aporeto-inc/trireme-lib | controller/pkg/claimsheader/ct.go | toMask | func (ct CompressionType) toMask() compressionTypeMask {
switch ct {
case CompressionTypeV1:
return compressionTypeV1Mask
case CompressionTypeV2:
return compressionTypeV2Mask
default:
return compressionTypeNoneMask
}
} | go | func (ct CompressionType) toMask() compressionTypeMask {
switch ct {
case CompressionTypeV1:
return compressionTypeV1Mask
case CompressionTypeV2:
return compressionTypeV2Mask
default:
return compressionTypeNoneMask
}
} | [
"func",
"(",
"ct",
"CompressionType",
")",
"toMask",
"(",
")",
"compressionTypeMask",
"{",
"switch",
"ct",
"{",
"case",
"CompressionTypeV1",
":",
"return",
"compressionTypeV1Mask",
"\n",
"case",
"CompressionTypeV2",
":",
"return",
"compressionTypeV2Mask",
"\n",
"def... | // toMask returns the mask based on the type | [
"toMask",
"returns",
"the",
"mask",
"based",
"on",
"the",
"type"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/ct.go#L26-L36 |
7,368 | aporeto-inc/trireme-lib | controller/pkg/claimsheader/ct.go | toType | func (cm compressionTypeMask) toType() CompressionType {
switch cm {
case compressionTypeV1Mask:
return CompressionTypeV1
case compressionTypeV2Mask:
return CompressionTypeV2
default:
return CompressionTypeNone
}
} | go | func (cm compressionTypeMask) toType() CompressionType {
switch cm {
case compressionTypeV1Mask:
return CompressionTypeV1
case compressionTypeV2Mask:
return CompressionTypeV2
default:
return CompressionTypeNone
}
} | [
"func",
"(",
"cm",
"compressionTypeMask",
")",
"toType",
"(",
")",
"CompressionType",
"{",
"switch",
"cm",
"{",
"case",
"compressionTypeV1Mask",
":",
"return",
"CompressionTypeV1",
"\n",
"case",
"compressionTypeV2Mask",
":",
"return",
"CompressionTypeV2",
"\n",
"def... | // toType returns the type based on mask | [
"toType",
"returns",
"the",
"type",
"based",
"on",
"mask"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/ct.go#L58-L68 |
7,369 | aporeto-inc/trireme-lib | controller/pkg/claimsheader/ct.go | String2CompressionType | func String2CompressionType(s string) CompressionType {
switch s {
case CompressionTypeV1.toString():
return CompressionTypeV1
case CompressionTypeV2.toString():
return CompressionTypeV2
default:
return CompressionTypeNone
}
} | go | func String2CompressionType(s string) CompressionType {
switch s {
case CompressionTypeV1.toString():
return CompressionTypeV1
case CompressionTypeV2.toString():
return CompressionTypeV2
default:
return CompressionTypeNone
}
} | [
"func",
"String2CompressionType",
"(",
"s",
"string",
")",
"CompressionType",
"{",
"switch",
"s",
"{",
"case",
"CompressionTypeV1",
".",
"toString",
"(",
")",
":",
"return",
"CompressionTypeV1",
"\n",
"case",
"CompressionTypeV2",
".",
"toString",
"(",
")",
":",
... | // String2CompressionType is a helper to convert string to compression type | [
"String2CompressionType",
"is",
"a",
"helper",
"to",
"convert",
"string",
"to",
"compression",
"type"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/ct.go#L94-L104 |
7,370 | aporeto-inc/trireme-lib | monitor/internal/pod/controller.go | newReconciler | func newReconciler(mgr manager.Manager, handler *config.ProcessorConfig, metadataExtractor extractors.PodMetadataExtractor, netclsProgrammer extractors.PodNetclsProgrammer, nodeName string, enableHostPods bool) *ReconcilePod {
return &ReconcilePod{
client: mgr.GetClient(),
scheme: mgr.GetScheme(),
recorder: mgr.GetRecorder("trireme-pod-controller"),
handler: handler,
metadataExtractor: metadataExtractor,
netclsProgrammer: netclsProgrammer,
nodeName: nodeName,
enableHostPods: enableHostPods,
// TODO: might move into configuration
handlePUEventTimeout: 5 * time.Second,
metadataExtractTimeout: 3 * time.Second,
netclsProgramTimeout: 2 * time.Second,
}
} | go | func newReconciler(mgr manager.Manager, handler *config.ProcessorConfig, metadataExtractor extractors.PodMetadataExtractor, netclsProgrammer extractors.PodNetclsProgrammer, nodeName string, enableHostPods bool) *ReconcilePod {
return &ReconcilePod{
client: mgr.GetClient(),
scheme: mgr.GetScheme(),
recorder: mgr.GetRecorder("trireme-pod-controller"),
handler: handler,
metadataExtractor: metadataExtractor,
netclsProgrammer: netclsProgrammer,
nodeName: nodeName,
enableHostPods: enableHostPods,
// TODO: might move into configuration
handlePUEventTimeout: 5 * time.Second,
metadataExtractTimeout: 3 * time.Second,
netclsProgramTimeout: 2 * time.Second,
}
} | [
"func",
"newReconciler",
"(",
"mgr",
"manager",
".",
"Manager",
",",
"handler",
"*",
"config",
".",
"ProcessorConfig",
",",
"metadataExtractor",
"extractors",
".",
"PodMetadataExtractor",
",",
"netclsProgrammer",
"extractors",
".",
"PodNetclsProgrammer",
",",
"nodeNam... | // newReconciler returns a new reconcile.Reconciler | [
"newReconciler",
"returns",
"a",
"new",
"reconcile",
".",
"Reconciler"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/pod/controller.go#L44-L60 |
7,371 | aporeto-inc/trireme-lib | monitor/internal/pod/controller.go | addController | func addController(mgr manager.Manager, r *ReconcilePod, eventsCh <-chan event.GenericEvent) error {
// Create a new controller
c, err := controller.New("trireme-pod-controller", mgr, controller.Options{Reconciler: r})
if err != nil {
return err
}
// we use this mapper in both of our event sources
mapper := &WatchPodMapper{
client: mgr.GetClient(),
nodeName: r.nodeName,
enableHostPods: r.enableHostPods,
}
// use the our watch pod mapper which filters pods before we reconcile
if err := c.Watch(
&source.Kind{Type: &corev1.Pod{}},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err != nil {
return err
}
// we pass in a custom channel for events generated by resync
if err := c.Watch(
&source.Channel{Source: eventsCh},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err != nil {
return err
}
return nil
} | go | func addController(mgr manager.Manager, r *ReconcilePod, eventsCh <-chan event.GenericEvent) error {
// Create a new controller
c, err := controller.New("trireme-pod-controller", mgr, controller.Options{Reconciler: r})
if err != nil {
return err
}
// we use this mapper in both of our event sources
mapper := &WatchPodMapper{
client: mgr.GetClient(),
nodeName: r.nodeName,
enableHostPods: r.enableHostPods,
}
// use the our watch pod mapper which filters pods before we reconcile
if err := c.Watch(
&source.Kind{Type: &corev1.Pod{}},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err != nil {
return err
}
// we pass in a custom channel for events generated by resync
if err := c.Watch(
&source.Channel{Source: eventsCh},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err != nil {
return err
}
return nil
} | [
"func",
"addController",
"(",
"mgr",
"manager",
".",
"Manager",
",",
"r",
"*",
"ReconcilePod",
",",
"eventsCh",
"<-",
"chan",
"event",
".",
"GenericEvent",
")",
"error",
"{",
"// Create a new controller",
"c",
",",
"err",
":=",
"controller",
".",
"New",
"(",... | // addController adds a new Controller to mgr with r as the reconcile.Reconciler | [
"addController",
"adds",
"a",
"new",
"Controller",
"to",
"mgr",
"with",
"r",
"as",
"the",
"reconcile",
".",
"Reconciler"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/pod/controller.go#L63-L94 |
7,372 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | NewProcessor | func NewProcessor(s secrets.Secrets, trustedCertificate *x509.Certificate) *Processor {
return &Processor{
aporetoJWT: servicetokens.NewVerifier(s, trustedCertificate),
}
} | go | func NewProcessor(s secrets.Secrets, trustedCertificate *x509.Certificate) *Processor {
return &Processor{
aporetoJWT: servicetokens.NewVerifier(s, trustedCertificate),
}
} | [
"func",
"NewProcessor",
"(",
"s",
"secrets",
".",
"Secrets",
",",
"trustedCertificate",
"*",
"x509",
".",
"Certificate",
")",
"*",
"Processor",
"{",
"return",
"&",
"Processor",
"{",
"aporetoJWT",
":",
"servicetokens",
".",
"NewVerifier",
"(",
"s",
",",
"trus... | // NewProcessor creates an auth processor with PKI user tokens. The caller
// must provide a valid secrets structure and an optional list of trustedCertificates
// that can be used to validate tokens. If the list is empty, the CA from the secrets
// will be used for token validation. | [
"NewProcessor",
"creates",
"an",
"auth",
"processor",
"with",
"PKI",
"user",
"tokens",
".",
"The",
"caller",
"must",
"provide",
"a",
"valid",
"secrets",
"structure",
"and",
"an",
"optional",
"list",
"of",
"trustedCertificates",
"that",
"can",
"be",
"used",
"to... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L35-L39 |
7,373 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | UpdateSecrets | func (p *Processor) UpdateSecrets(s secrets.Secrets, trustedCertificate *x509.Certificate) {
p.aporetoJWT.UpdateSecrets(s, trustedCertificate)
} | go | func (p *Processor) UpdateSecrets(s secrets.Secrets, trustedCertificate *x509.Certificate) {
p.aporetoJWT.UpdateSecrets(s, trustedCertificate)
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"UpdateSecrets",
"(",
"s",
"secrets",
".",
"Secrets",
",",
"trustedCertificate",
"*",
"x509",
".",
"Certificate",
")",
"{",
"p",
".",
"aporetoJWT",
".",
"UpdateSecrets",
"(",
"s",
",",
"trustedCertificate",
")",
"\n... | // UpdateSecrets will update the Aporeto secrets for the validation of the
// Aporeto tokens. | [
"UpdateSecrets",
"will",
"update",
"the",
"Aporeto",
"secrets",
"for",
"the",
"validation",
"of",
"the",
"Aporeto",
"tokens",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L43-L45 |
7,374 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | AddOrUpdateService | func (p *Processor) AddOrUpdateService(apis *urisearch.APICache, serviceType policy.UserAuthorizationTypeValues, handler usertokens.Verifier, mappings map[string]string) {
p.Lock()
defer p.Unlock()
p.apis = apis
p.userTokenMappings = mappings
p.userTokenHandler = handler
p.userAuthorizationType = serviceType
} | go | func (p *Processor) AddOrUpdateService(apis *urisearch.APICache, serviceType policy.UserAuthorizationTypeValues, handler usertokens.Verifier, mappings map[string]string) {
p.Lock()
defer p.Unlock()
p.apis = apis
p.userTokenMappings = mappings
p.userTokenHandler = handler
p.userAuthorizationType = serviceType
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"AddOrUpdateService",
"(",
"apis",
"*",
"urisearch",
".",
"APICache",
",",
"serviceType",
"policy",
".",
"UserAuthorizationTypeValues",
",",
"handler",
"usertokens",
".",
"Verifier",
",",
"mappings",
"map",
"[",
"string",... | // AddOrUpdateService adds or replaces a service in the authorization db. | [
"AddOrUpdateService",
"adds",
"or",
"replaces",
"a",
"service",
"in",
"the",
"authorization",
"db",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L48-L56 |
7,375 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | UpdateServiceAPIs | func (p *Processor) UpdateServiceAPIs(apis *urisearch.APICache) error {
p.Lock()
defer p.Unlock()
p.apis = apis
return nil
} | go | func (p *Processor) UpdateServiceAPIs(apis *urisearch.APICache) error {
p.Lock()
defer p.Unlock()
p.apis = apis
return nil
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"UpdateServiceAPIs",
"(",
"apis",
"*",
"urisearch",
".",
"APICache",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"apis",
"=",
"apis",
"\n",
... | // UpdateServiceAPIs updates an existing service with a new API definition. | [
"UpdateServiceAPIs",
"updates",
"an",
"existing",
"service",
"with",
"a",
"new",
"API",
"definition",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L59-L65 |
7,376 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | DecodeUserClaims | func (p *Processor) DecodeUserClaims(name, userToken string, certs []*x509.Certificate, r *http.Request) ([]string, bool, string, error) {
switch p.userAuthorizationType {
case policy.UserAuthorizationMutualTLS, policy.UserAuthorizationJWT:
// First parse any incoming certificates and retrieve attributes from them.
// This is used in case of client authorization with certificates.
attributes := []string{}
for _, cert := range certs {
attributes = append(attributes, "CN="+cert.Subject.CommonName)
for _, email := range cert.EmailAddresses {
attributes = append(attributes, "Email="+email)
}
for _, org := range cert.Subject.Organization {
attributes = append(attributes, "O="+org)
}
for _, org := range cert.Subject.OrganizationalUnit {
attributes = append(attributes, "OU="+org)
}
}
if p.userAuthorizationType == policy.UserAuthorizationJWT && p.userTokenHandler != nil {
jwtAttributes, _, _, err := p.userTokenHandler.Validate(r.Context(), userToken)
if err != nil {
return attributes, false, userToken, fmt.Errorf("Unable to decode JWT: %s", err)
}
attributes = append(attributes, jwtAttributes...)
}
return attributes, false, userToken, nil
case policy.UserAuthorizationOIDC:
// Now we can parse the user claims.
if p.userTokenHandler == nil {
zap.L().Error("Internal Server Error: OIDC User Token Handler not configured")
return []string{}, false, userToken, nil
}
return p.userTokenHandler.Validate(r.Context(), userToken)
default:
return []string{}, false, userToken, nil
}
} | go | func (p *Processor) DecodeUserClaims(name, userToken string, certs []*x509.Certificate, r *http.Request) ([]string, bool, string, error) {
switch p.userAuthorizationType {
case policy.UserAuthorizationMutualTLS, policy.UserAuthorizationJWT:
// First parse any incoming certificates and retrieve attributes from them.
// This is used in case of client authorization with certificates.
attributes := []string{}
for _, cert := range certs {
attributes = append(attributes, "CN="+cert.Subject.CommonName)
for _, email := range cert.EmailAddresses {
attributes = append(attributes, "Email="+email)
}
for _, org := range cert.Subject.Organization {
attributes = append(attributes, "O="+org)
}
for _, org := range cert.Subject.OrganizationalUnit {
attributes = append(attributes, "OU="+org)
}
}
if p.userAuthorizationType == policy.UserAuthorizationJWT && p.userTokenHandler != nil {
jwtAttributes, _, _, err := p.userTokenHandler.Validate(r.Context(), userToken)
if err != nil {
return attributes, false, userToken, fmt.Errorf("Unable to decode JWT: %s", err)
}
attributes = append(attributes, jwtAttributes...)
}
return attributes, false, userToken, nil
case policy.UserAuthorizationOIDC:
// Now we can parse the user claims.
if p.userTokenHandler == nil {
zap.L().Error("Internal Server Error: OIDC User Token Handler not configured")
return []string{}, false, userToken, nil
}
return p.userTokenHandler.Validate(r.Context(), userToken)
default:
return []string{}, false, userToken, nil
}
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"DecodeUserClaims",
"(",
"name",
",",
"userToken",
"string",
",",
"certs",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"[",
"]",
"string",
",",
"bool",
",",
"s... | // DecodeUserClaims decodes the user claims with the user authorization method. | [
"DecodeUserClaims",
"decodes",
"the",
"user",
"claims",
"with",
"the",
"user",
"authorization",
"method",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L68-L108 |
7,377 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | DecodeAporetoClaims | func (p *Processor) DecodeAporetoClaims(aporetoToken string, publicKey string) (string, []string, error) {
if len(aporetoToken) == 0 || p.aporetoJWT == nil {
return "", []string{}, nil
}
// Finally we can parse the Aporeto token.
id, scopes, profile, err := p.aporetoJWT.ParseToken(aporetoToken, publicKey)
if err != nil {
return "", []string{}, fmt.Errorf("Invalid Aporeto Token: %s", err)
}
return id, append(profile, scopes...), nil
} | go | func (p *Processor) DecodeAporetoClaims(aporetoToken string, publicKey string) (string, []string, error) {
if len(aporetoToken) == 0 || p.aporetoJWT == nil {
return "", []string{}, nil
}
// Finally we can parse the Aporeto token.
id, scopes, profile, err := p.aporetoJWT.ParseToken(aporetoToken, publicKey)
if err != nil {
return "", []string{}, fmt.Errorf("Invalid Aporeto Token: %s", err)
}
return id, append(profile, scopes...), nil
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"DecodeAporetoClaims",
"(",
"aporetoToken",
"string",
",",
"publicKey",
"string",
")",
"(",
"string",
",",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"len",
"(",
"aporetoToken",
")",
"==",
"0",
"||",
"p",... | // DecodeAporetoClaims decodes the Aporeto claims | [
"DecodeAporetoClaims",
"decodes",
"the",
"Aporeto",
"claims"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L111-L122 |
7,378 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | Callback | func (p *Processor) Callback(w http.ResponseWriter, r *http.Request) {
p.RLock()
defer p.RUnlock()
// Validate the JWT token through the handler.
token, originURL, status, err := p.userTokenHandler.Callback(r)
if err != nil {
http.Error(w, fmt.Sprintf("Invalid code %s:", err), http.StatusInternalServerError)
return
}
cookie := &http.Cookie{
Name: "X-APORETO-AUTH",
Value: token,
HttpOnly: true,
Secure: true,
Path: "/",
}
http.SetCookie(w, cookie)
// We transmit the information in the return payload for applications
// that choose to use it directly without a cookie.
data, err := json.MarshalIndent(cookie, " ", " ")
if err != nil {
http.Error(w, "Bad data", http.StatusInternalServerError)
return
}
// We redirect here to the original URL that the application attempted
// to access.
w.Header().Add("Location", originURL)
http.Error(w, string(data), status)
} | go | func (p *Processor) Callback(w http.ResponseWriter, r *http.Request) {
p.RLock()
defer p.RUnlock()
// Validate the JWT token through the handler.
token, originURL, status, err := p.userTokenHandler.Callback(r)
if err != nil {
http.Error(w, fmt.Sprintf("Invalid code %s:", err), http.StatusInternalServerError)
return
}
cookie := &http.Cookie{
Name: "X-APORETO-AUTH",
Value: token,
HttpOnly: true,
Secure: true,
Path: "/",
}
http.SetCookie(w, cookie)
// We transmit the information in the return payload for applications
// that choose to use it directly without a cookie.
data, err := json.MarshalIndent(cookie, " ", " ")
if err != nil {
http.Error(w, "Bad data", http.StatusInternalServerError)
return
}
// We redirect here to the original URL that the application attempted
// to access.
w.Header().Add("Location", originURL)
http.Error(w, string(data), status)
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"Callback",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Validate the JWT tok... | // Callback is function called by and IDP auth provider will exchange the provided
// authorization code with a JWT token. This closes the Oauth loop. | [
"Callback",
"is",
"function",
"called",
"by",
"and",
"IDP",
"auth",
"provider",
"will",
"exchange",
"the",
"provided",
"authorization",
"code",
"with",
"a",
"JWT",
"token",
".",
"This",
"closes",
"the",
"Oauth",
"loop",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L126-L159 |
7,379 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | Check | func (p *Processor) Check(method, uri string, claims []string) (bool, bool) {
p.RLock()
defer p.RUnlock()
return p.apis.FindAndMatchScope(method, uri, claims)
} | go | func (p *Processor) Check(method, uri string, claims []string) (bool, bool) {
p.RLock()
defer p.RUnlock()
return p.apis.FindAndMatchScope(method, uri, claims)
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"Check",
"(",
"method",
",",
"uri",
"string",
",",
"claims",
"[",
"]",
"string",
")",
"(",
"bool",
",",
"bool",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n"... | // Check is the main method that will search API cache and validate whether the call should
// be allowed. It returns two values. If the access is allowed, and whether the access
// public or not. This allows callers to decide what to do when there is a failure, and
// potentially issue a redirect. | [
"Check",
"is",
"the",
"main",
"method",
"that",
"will",
"search",
"API",
"cache",
"and",
"validate",
"whether",
"the",
"call",
"should",
"be",
"allowed",
".",
"It",
"returns",
"two",
"values",
".",
"If",
"the",
"access",
"is",
"allowed",
"and",
"whether",
... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L165-L170 |
7,380 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | RedirectURI | func (p *Processor) RedirectURI(originURL string) string {
p.RLock()
defer p.RUnlock()
return p.userTokenHandler.IssueRedirect(originURL)
} | go | func (p *Processor) RedirectURI(originURL string) string {
p.RLock()
defer p.RUnlock()
return p.userTokenHandler.IssueRedirect(originURL)
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"RedirectURI",
"(",
"originURL",
"string",
")",
"string",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"userTokenHandler",
".",
"IssueRedirect",
"("... | // RedirectURI returns the redirect URI in order to start the authentication dance. | [
"RedirectURI",
"returns",
"the",
"redirect",
"URI",
"in",
"order",
"to",
"start",
"the",
"authentication",
"dance",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L173-L178 |
7,381 | aporeto-inc/trireme-lib | controller/pkg/auth/auth.go | UpdateRequestHeaders | func (p *Processor) UpdateRequestHeaders(r *http.Request, claims []string) {
p.RLock()
defer p.RUnlock()
if len(p.userTokenMappings) == 0 {
return
}
for _, claim := range claims {
parts := strings.SplitN(claim, "=", 2)
if header, ok := p.userTokenMappings[parts[0]]; ok && len(parts) == 2 {
r.Header.Add(header, parts[1])
}
}
} | go | func (p *Processor) UpdateRequestHeaders(r *http.Request, claims []string) {
p.RLock()
defer p.RUnlock()
if len(p.userTokenMappings) == 0 {
return
}
for _, claim := range claims {
parts := strings.SplitN(claim, "=", 2)
if header, ok := p.userTokenMappings[parts[0]]; ok && len(parts) == 2 {
r.Header.Add(header, parts[1])
}
}
} | [
"func",
"(",
"p",
"*",
"Processor",
")",
"UpdateRequestHeaders",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"claims",
"[",
"]",
"string",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"len",
"... | // UpdateRequestHeaders will update the request headers based on the user claims
// and the corresponding mappings. | [
"UpdateRequestHeaders",
"will",
"update",
"the",
"request",
"headers",
"based",
"on",
"the",
"user",
"claims",
"and",
"the",
"corresponding",
"mappings",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/auth/auth.go#L182-L196 |
7,382 | aporeto-inc/trireme-lib | controller/pkg/fqconfig/fqconfig.go | NewFilterQueueWithDefaults | func NewFilterQueueWithDefaults() *FilterQueue {
return NewFilterQueue(
DefaultQueueSeperation,
DefaultMarkValue,
DefaultQueueStart,
DefaultNumberOfQueues,
DefaultNumberOfQueues,
DefaultQueueSize,
DefaultQueueSize,
)
} | go | func NewFilterQueueWithDefaults() *FilterQueue {
return NewFilterQueue(
DefaultQueueSeperation,
DefaultMarkValue,
DefaultQueueStart,
DefaultNumberOfQueues,
DefaultNumberOfQueues,
DefaultQueueSize,
DefaultQueueSize,
)
} | [
"func",
"NewFilterQueueWithDefaults",
"(",
")",
"*",
"FilterQueue",
"{",
"return",
"NewFilterQueue",
"(",
"DefaultQueueSeperation",
",",
"DefaultMarkValue",
",",
"DefaultQueueStart",
",",
"DefaultNumberOfQueues",
",",
"DefaultNumberOfQueues",
",",
"DefaultQueueSize",
",",
... | // NewFilterQueueWithDefaults return a default filter queue config | [
"NewFilterQueueWithDefaults",
"return",
"a",
"default",
"filter",
"queue",
"config"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/fqconfig/fqconfig.go#L42-L52 |
7,383 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/kubernetes.go | hasSynced | func hasSynced(sync chan struct{}, controller kubecache.Controller) {
for {
if controller.HasSynced() {
sync <- struct{}{}
return
}
<-time.After(100 * time.Millisecond)
}
} | go | func hasSynced(sync chan struct{}, controller kubecache.Controller) {
for {
if controller.HasSynced() {
sync <- struct{}{}
return
}
<-time.After(100 * time.Millisecond)
}
} | [
"func",
"hasSynced",
"(",
"sync",
"chan",
"struct",
"{",
"}",
",",
"controller",
"kubecache",
".",
"Controller",
")",
"{",
"for",
"{",
"if",
"controller",
".",
"HasSynced",
"(",
")",
"{",
"sync",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"return",
"\... | // hasSynced sends an event on the Sync chan when the attachedController finished syncing. | [
"hasSynced",
"sends",
"an",
"event",
"on",
"the",
"Sync",
"chan",
"when",
"the",
"attachedController",
"finished",
"syncing",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/kubernetes.go#L77-L85 |
7,384 | aporeto-inc/trireme-lib | utils/nfqparser/nfqparser.go | Synchronize | func (n *NFQParser) Synchronize() error {
n.Lock()
defer n.Unlock()
data, err := ioutil.ReadFile(n.filePath)
if err != nil {
return err
}
n.nfqStr = string(data)
scanner := bufio.NewScanner(bytes.NewReader(data))
for scanner.Scan() {
line := scanner.Text()
lineParts := strings.Fields(line)
newNFQ := makeNFQLayout(lineParts)
n.contents[newNFQ.QueueNum] = newNFQ
}
return nil
} | go | func (n *NFQParser) Synchronize() error {
n.Lock()
defer n.Unlock()
data, err := ioutil.ReadFile(n.filePath)
if err != nil {
return err
}
n.nfqStr = string(data)
scanner := bufio.NewScanner(bytes.NewReader(data))
for scanner.Scan() {
line := scanner.Text()
lineParts := strings.Fields(line)
newNFQ := makeNFQLayout(lineParts)
n.contents[newNFQ.QueueNum] = newNFQ
}
return nil
} | [
"func",
"(",
"n",
"*",
"NFQParser",
")",
"Synchronize",
"(",
")",
"error",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"n",
".",
"filePath",
")",
... | // Synchronize reads from file and parses it | [
"Synchronize",
"reads",
"from",
"file",
"and",
"parses",
"it"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/nfqparser/nfqparser.go#L31-L53 |
7,385 | aporeto-inc/trireme-lib | utils/nfqparser/nfqparser.go | RetrieveByQueue | func (n *NFQParser) RetrieveByQueue(queueNum string) *NFQLayout {
n.Lock()
defer n.Unlock()
content, ok := n.contents[queueNum]
if ok {
return &content
}
return nil
} | go | func (n *NFQParser) RetrieveByQueue(queueNum string) *NFQLayout {
n.Lock()
defer n.Unlock()
content, ok := n.contents[queueNum]
if ok {
return &content
}
return nil
} | [
"func",
"(",
"n",
"*",
"NFQParser",
")",
"RetrieveByQueue",
"(",
"queueNum",
"string",
")",
"*",
"NFQLayout",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n\n",
"content",
",",
"ok",
":=",
"n",
".",
"contents",
"[... | // RetrieveByQueue returns layout for a specific queue number | [
"RetrieveByQueue",
"returns",
"layout",
"for",
"a",
"specific",
"queue",
"number"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/nfqparser/nfqparser.go#L56-L67 |
7,386 | aporeto-inc/trireme-lib | utils/nfqparser/nfqparser.go | RetrieveAll | func (n *NFQParser) RetrieveAll() map[string]NFQLayout {
n.Lock()
defer n.Unlock()
return n.contents
} | go | func (n *NFQParser) RetrieveAll() map[string]NFQLayout {
n.Lock()
defer n.Unlock()
return n.contents
} | [
"func",
"(",
"n",
"*",
"NFQParser",
")",
"RetrieveAll",
"(",
")",
"map",
"[",
"string",
"]",
"NFQLayout",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"n",
".",
"contents",
"\n",
"}"
] | // RetrieveAll returns all layouts | [
"RetrieveAll",
"returns",
"all",
"layouts"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/nfqparser/nfqparser.go#L70-L76 |
7,387 | aporeto-inc/trireme-lib | utils/nfqparser/nfqparser.go | String | func (n *NFQParser) String() string {
n.Lock()
defer n.Unlock()
return n.nfqStr
} | go | func (n *NFQParser) String() string {
n.Lock()
defer n.Unlock()
return n.nfqStr
} | [
"func",
"(",
"n",
"*",
"NFQParser",
")",
"String",
"(",
")",
"string",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"n",
".",
"nfqStr",
"\n",
"}"
] | // String returns string renresentation of nfqueue data | [
"String",
"returns",
"string",
"renresentation",
"of",
"nfqueue",
"data"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/nfqparser/nfqparser.go#L79-L85 |
7,388 | aporeto-inc/trireme-lib | monitor/processor/mockprocessor/mockprocessor.go | NewMockProcessor | func NewMockProcessor(ctrl *gomock.Controller) *MockProcessor {
mock := &MockProcessor{ctrl: ctrl}
mock.recorder = &MockProcessorMockRecorder{mock}
return mock
} | go | func NewMockProcessor(ctrl *gomock.Controller) *MockProcessor {
mock := &MockProcessor{ctrl: ctrl}
mock.recorder = &MockProcessorMockRecorder{mock}
return mock
} | [
"func",
"NewMockProcessor",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockProcessor",
"{",
"mock",
":=",
"&",
"MockProcessor",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockProcessorMockRecorder",
"{",
"mock",
... | // NewMockProcessor creates a new mock instance
// nolint | [
"NewMockProcessor",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/processor/mockprocessor/mockprocessor.go#L30-L34 |
7,389 | aporeto-inc/trireme-lib | monitor/processor/mockprocessor/mockprocessor.go | Start | func (m *MockProcessor) Start(ctx context.Context, eventInfo *common.EventInfo) error {
ret := m.ctrl.Call(m, "Start", ctx, eventInfo)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockProcessor) Start(ctx context.Context, eventInfo *common.EventInfo) error {
ret := m.ctrl.Call(m, "Start", ctx, eventInfo)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockProcessor",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
",",
"eventInfo",
"*",
"common",
".",
"EventInfo",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
... | // Start mocks base method
// nolint | [
"Start",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/processor/mockprocessor/mockprocessor.go#L44-L48 |
7,390 | aporeto-inc/trireme-lib | monitor/processor/mockprocessor/mockprocessor.go | Start | func (mr *MockProcessorMockRecorder) Start(ctx, eventInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockProcessor)(nil).Start), ctx, eventInfo)
} | go | func (mr *MockProcessorMockRecorder) Start(ctx, eventInfo interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockProcessor)(nil).Start), ctx, eventInfo)
} | [
"func",
"(",
"mr",
"*",
"MockProcessorMockRecorder",
")",
"Start",
"(",
"ctx",
",",
"eventInfo",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock... | // Start indicates an expected call of Start
// nolint | [
"Start",
"indicates",
"an",
"expected",
"call",
"of",
"Start",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/processor/mockprocessor/mockprocessor.go#L52-L54 |
7,391 | aporeto-inc/trireme-lib | policy/tagstore.go | NewTagStoreFromMap | func NewTagStoreFromMap(tags map[string]string) *TagStore {
t := &TagStore{make([]string, len(tags))}
i := 0
for k, v := range tags {
t.Tags[i] = k + "=" + v
i++
}
return t
} | go | func NewTagStoreFromMap(tags map[string]string) *TagStore {
t := &TagStore{make([]string, len(tags))}
i := 0
for k, v := range tags {
t.Tags[i] = k + "=" + v
i++
}
return t
} | [
"func",
"NewTagStoreFromMap",
"(",
"tags",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"TagStore",
"{",
"t",
":=",
"&",
"TagStore",
"{",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"tags",
")",
")",
"}",
"\n",
"i",
":=",
"0",
"\n",
"for"... | // NewTagStoreFromMap creates a tag store from an input map | [
"NewTagStoreFromMap",
"creates",
"a",
"tag",
"store",
"from",
"an",
"input",
"map"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/tagstore.go#L23-L31 |
7,392 | aporeto-inc/trireme-lib | policy/tagstore.go | Copy | func (t *TagStore) Copy() *TagStore {
c := make([]string, len(t.Tags))
copy(c, t.Tags)
return &TagStore{c}
} | go | func (t *TagStore) Copy() *TagStore {
c := make([]string, len(t.Tags))
copy(c, t.Tags)
return &TagStore{c}
} | [
"func",
"(",
"t",
"*",
"TagStore",
")",
"Copy",
"(",
")",
"*",
"TagStore",
"{",
"c",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"t",
".",
"Tags",
")",
")",
"\n\n",
"copy",
"(",
"c",
",",
"t",
".",
"Tags",
")",
"\n\n",
"return",
... | // Copy copies a TagStore | [
"Copy",
"copies",
"a",
"TagStore"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/tagstore.go#L39-L46 |
7,393 | aporeto-inc/trireme-lib | policy/tagstore.go | Get | func (t *TagStore) Get(key string) (string, bool) {
for _, kv := range t.Tags {
parts := strings.SplitN(kv, "=", 2)
if len(parts) != 2 {
continue
}
if key == parts[0] {
return parts[1], true
}
}
return "", false
} | go | func (t *TagStore) Get(key string) (string, bool) {
for _, kv := range t.Tags {
parts := strings.SplitN(kv, "=", 2)
if len(parts) != 2 {
continue
}
if key == parts[0] {
return parts[1], true
}
}
return "", false
} | [
"func",
"(",
"t",
"*",
"TagStore",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"for",
"_",
",",
"kv",
":=",
"range",
"t",
".",
"Tags",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"kv",
",",
"\"",
"\"",
... | // Get does a lookup in the list of tags | [
"Get",
"does",
"a",
"lookup",
"in",
"the",
"list",
"of",
"tags"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/tagstore.go#L49-L62 |
7,394 | aporeto-inc/trireme-lib | policy/tagstore.go | Merge | func (t *TagStore) Merge(m *TagStore) (merged int) {
for _, kv := range m.Tags {
parts := strings.SplitN(kv, "=", 2)
if len(parts) != 2 {
continue
}
if _, ok := t.Get(parts[0]); !ok {
t.AppendKeyValue(parts[0], parts[1])
merged++
}
}
return merged
} | go | func (t *TagStore) Merge(m *TagStore) (merged int) {
for _, kv := range m.Tags {
parts := strings.SplitN(kv, "=", 2)
if len(parts) != 2 {
continue
}
if _, ok := t.Get(parts[0]); !ok {
t.AppendKeyValue(parts[0], parts[1])
merged++
}
}
return merged
} | [
"func",
"(",
"t",
"*",
"TagStore",
")",
"Merge",
"(",
"m",
"*",
"TagStore",
")",
"(",
"merged",
"int",
")",
"{",
"for",
"_",
",",
"kv",
":=",
"range",
"m",
".",
"Tags",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"kv",
",",
"\"",
"\"",
... | // Merge merges tags from m into native tag store. if the key exists, the provided
// tag from m is ignored. | [
"Merge",
"merges",
"tags",
"from",
"m",
"into",
"native",
"tag",
"store",
".",
"if",
"the",
"key",
"exists",
"the",
"provided",
"tag",
"from",
"m",
"is",
"ignored",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/tagstore.go#L66-L79 |
7,395 | aporeto-inc/trireme-lib | policy/tagstore.go | AppendKeyValue | func (t *TagStore) AppendKeyValue(key, value string) {
t.Tags = append(t.Tags, key+"="+value)
} | go | func (t *TagStore) AppendKeyValue(key, value string) {
t.Tags = append(t.Tags, key+"="+value)
} | [
"func",
"(",
"t",
"*",
"TagStore",
")",
"AppendKeyValue",
"(",
"key",
",",
"value",
"string",
")",
"{",
"t",
".",
"Tags",
"=",
"append",
"(",
"t",
".",
"Tags",
",",
"key",
"+",
"\"",
"\"",
"+",
"value",
")",
"\n",
"}"
] | // AppendKeyValue appends a key and value to the tag store | [
"AppendKeyValue",
"appends",
"a",
"key",
"and",
"value",
"to",
"the",
"tag",
"store"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/tagstore.go#L82-L84 |
7,396 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/transport.go | RoundTrip | func (t *TriremeRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
res, err := t.RoundTripper.RoundTrip(req)
if err != nil || res == nil {
return res, err
}
data := req.Context().Value(statsContextKey)
if data == nil {
return res, nil
}
state, ok := data.(*connectionState)
if ok && state.cookie == nil {
return res, nil
}
if v := state.cookie.String(); v != "" {
res.Header.Add("Set-Cookie", v)
}
return res, nil
} | go | func (t *TriremeRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
res, err := t.RoundTripper.RoundTrip(req)
if err != nil || res == nil {
return res, err
}
data := req.Context().Value(statsContextKey)
if data == nil {
return res, nil
}
state, ok := data.(*connectionState)
if ok && state.cookie == nil {
return res, nil
}
if v := state.cookie.String(); v != "" {
res.Header.Add("Set-Cookie", v)
}
return res, nil
} | [
"func",
"(",
"t",
"*",
"TriremeRoundTripper",
")",
"RoundTrip",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"t",
".",
"RoundTripper",
".",
"RoundTrip",
"(",
"req",
... | // RoundTrip implements the RoundTripper interface. It will add a cookie
// in the response in case of OIDC requests with refresh tokens. | [
"RoundTrip",
"implements",
"the",
"RoundTripper",
"interface",
".",
"It",
"will",
"add",
"a",
"cookie",
"in",
"the",
"response",
"in",
"case",
"of",
"OIDC",
"requests",
"with",
"refresh",
"tokens",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/transport.go#L23-L45 |
7,397 | aporeto-inc/trireme-lib | monitor/internal/uid/monitor.go | Resync | func (u *UIDMonitor) Resync(ctx context.Context) error {
return u.proc.Resync(ctx, nil)
} | go | func (u *UIDMonitor) Resync(ctx context.Context) error {
return u.proc.Resync(ctx, nil)
} | [
"func",
"(",
"u",
"*",
"UIDMonitor",
")",
"Resync",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"u",
".",
"proc",
".",
"Resync",
"(",
"ctx",
",",
"nil",
")",
"\n",
"}"
] | // Resync asks the monitor to do a resync | [
"Resync",
"asks",
"the",
"monitor",
"to",
"do",
"a",
"resync"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/uid/monitor.go#L85-L87 |
7,398 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/debugclient/mockdebugclient/mockdebugclient.go | NewMockDebugClient | func NewMockDebugClient(ctrl *gomock.Controller) *MockDebugClient {
mock := &MockDebugClient{ctrl: ctrl}
mock.recorder = &MockDebugClientMockRecorder{mock}
return mock
} | go | func NewMockDebugClient(ctrl *gomock.Controller) *MockDebugClient {
mock := &MockDebugClient{ctrl: ctrl}
mock.recorder = &MockDebugClientMockRecorder{mock}
return mock
} | [
"func",
"NewMockDebugClient",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockDebugClient",
"{",
"mock",
":=",
"&",
"MockDebugClient",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockDebugClientMockRecorder",
"{",
"... | // NewMockDebugClient creates a new mock instance
// nolint | [
"NewMockDebugClient",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/debugclient/mockdebugclient/mockdebugclient.go#L29-L33 |
7,399 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/debugclient/mockdebugclient/mockdebugclient.go | Run | func (m *MockDebugClient) Run(ctx context.Context) error {
ret := m.ctrl.Call(m, "Run", ctx)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockDebugClient) Run(ctx context.Context) error {
ret := m.ctrl.Call(m, "Run", ctx)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockDebugClient",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
... | // Run mocks base method
// nolint | [
"Run",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/debugclient/mockdebugclient/mockdebugclient.go#L43-L47 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.