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",
"(",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"digest",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"[",
"]",
"byte",
"(",
"rpcClient",
".",
"Secret",
")",
")",
"\n",
"hash",
",",
"err",
":=",
"payloadHash",
"(",
"req",
".",
"Payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"digest",
".",
"Write",
"(",
"hash",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"req",
".",
"HashAuth",
"=",
"digest",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"return",
"rpcClient",
".",
"Client",
".",
"Call",
"(",
"methodName",
",",
"req",
",",
"resp",
")",
"\n",
"}"
] | // 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",
"hash",
",",
"err",
":=",
"payloadHash",
"(",
"req",
".",
"Payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"digest",
".",
"Write",
"(",
"hash",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"hmac",
".",
"Equal",
"(",
"req",
".",
"HashAuth",
",",
"digest",
".",
"Sum",
"(",
"nil",
")",
")",
"\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",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Register RPC Type",
"RegisterTypes",
"(",
")",
"\n\n",
"// Register handlers",
"if",
"err",
":=",
"rpc",
".",
"Register",
"(",
"handler",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"rpc",
".",
"HandleHTTP",
"(",
")",
"\n\n",
"// 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",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"path",
")",
")",
"\n\n",
"if",
"rerr",
":=",
"os",
".",
"Remove",
"(",
"path",
")",
";",
"rerr",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
",",
"rerr",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Get listener",
"listen",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"protocol",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"go",
"http",
".",
"Serve",
"(",
"listen",
",",
"nil",
")",
"// nolint",
"\n\n",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n\n",
"if",
"merr",
":=",
"listen",
".",
"Close",
"(",
")",
";",
"merr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"merr",
")",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"path",
")",
"\n",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
"contextID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"rpcHdl",
".",
"(",
"*",
"RPCHdl",
")",
".",
"Client",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"os",
".",
"Remove",
"(",
"rpcHdl",
".",
"(",
"*",
"RPCHdl",
")",
".",
"Channel",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"r",
".",
"rpcClientMap",
".",
"Remove",
"(",
"contextID",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
":=",
"range",
"keylist",
"{",
"if",
"kstring",
",",
"ok",
":=",
"key",
".",
"(",
"string",
")",
";",
"ok",
"{",
"contextArray",
"=",
"append",
"(",
"contextArray",
",",
"kstring",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"contextArray",
"\n",
"}"
] | // 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",
"[",
"]",
"byte",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"buf",
",",
"hash",
")",
"\n",
"return",
"buf",
",",
"nil",
"\n",
"}"
] | // 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",
"(",
"&",
"oidc",
".",
"TokenVerifier",
"{",
"}",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"InitRequestPayload",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"InitResponsePayload",
"{",
"}",
")",
")",
"\n\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"EnforcePayload",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"UnEnforcePayload",
"{",
"}",
")",
")",
"\n\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"StatsPayload",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"UpdateSecretsPayload",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"SetTargetNetworksPayload",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"EnableIPTablesPacketTracingPayLoad",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"EnableDatapathPacketTracingPayLoad",
"{",
"}",
")",
")",
"\n",
"gob",
".",
"RegisterName",
"(",
"\"",
"\"",
",",
"*",
"(",
"&",
"DebugPacketPayload",
"{",
"}",
")",
")",
"\n",
"}"
] | // 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",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"puType",
")",
"\n",
"}",
"\n\n",
"r",
".",
"handlers",
"[",
"puType",
"]",
"=",
"map",
"[",
"common",
".",
"Event",
"]",
"common",
".",
"EventHandler",
"{",
"}",
"\n\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventStart",
",",
"ep",
".",
"Start",
")",
"\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventStop",
",",
"ep",
".",
"Stop",
")",
"\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventCreate",
",",
"ep",
".",
"Create",
")",
"\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventDestroy",
",",
"ep",
".",
"Destroy",
")",
"\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventPause",
",",
"ep",
".",
"Pause",
")",
"\n",
"r",
".",
"addHandler",
"(",
"puType",
",",
"common",
".",
"EventResync",
",",
"ep",
".",
"Resync",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"error",
")",
"{",
"if",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n\n",
"case",
"packet",
".",
"TCPAckMask",
":",
"return",
"nil",
",",
"d",
".",
"processApplicationAckPacket",
"(",
"tcpPacket",
",",
"context",
",",
"conn",
")",
"\n\n",
"case",
"packet",
".",
"TCPSynAckMask",
":",
"return",
"nil",
",",
"d",
".",
"processApplicationSynAckPacket",
"(",
"tcpPacket",
",",
"context",
",",
"conn",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"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",
"(",
")",
")",
"\n\n",
"if",
"perr",
"!=",
"nil",
"{",
"report",
",",
"policy",
",",
"perr",
":=",
"context",
".",
"ApplicationACLPolicyFromAddr",
"(",
"tcpPacket",
".",
"DestinationAddress",
"(",
")",
",",
"tcpPacket",
".",
"DestPort",
"(",
")",
")",
"\n\n",
"if",
"perr",
"==",
"nil",
"&&",
"policy",
".",
"Action",
".",
"Accepted",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"d",
".",
"reportExternalServiceFlow",
"(",
"context",
",",
"report",
",",
"pkt",
",",
"true",
",",
"tcpPacket",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"policy",
",",
"err",
":=",
"context",
".",
"RetrieveCachedExternalFlowPolicy",
"(",
"tcpPacket",
".",
"DestinationAddress",
"(",
")",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"tcpPacket",
".",
"DestPort",
"(",
")",
")",
")",
")",
";",
"err",
"==",
"nil",
"{",
"d",
".",
"appOrigConnectionTracker",
".",
"AddOrUpdate",
"(",
"tcpPacket",
".",
"L4FlowHash",
"(",
")",
",",
"conn",
")",
"\n",
"d",
".",
"sourcePortConnectionCache",
".",
"AddOrUpdate",
"(",
"tcpPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeApplication",
")",
",",
"conn",
")",
"\n",
"return",
"policy",
",",
"nil",
"\n",
"}",
"\n\n",
"// We are now processing as a Trireme packet that needs authorization headers",
"// Create TCP Option",
"tcpOptions",
":=",
"d",
".",
"createTCPAuthenticationOption",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"\n\n",
"// Create a token",
"tcpData",
",",
"err",
":=",
"d",
".",
"tokenAccessor",
".",
"CreateSynPacketToken",
"(",
"context",
",",
"&",
"conn",
".",
"Auth",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Set the state indicating that we send out a Syn packet",
"conn",
".",
"SetState",
"(",
"connection",
".",
"TCPSynSend",
")",
"\n\n",
"// Poplate the caches to track the connection",
"hash",
":=",
"tcpPacket",
".",
"L4FlowHash",
"(",
")",
"\n",
"d",
".",
"appOrigConnectionTracker",
".",
"AddOrUpdate",
"(",
"hash",
",",
"conn",
")",
"\n",
"d",
".",
"sourcePortConnectionCache",
".",
"AddOrUpdate",
"(",
"tcpPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeApplication",
")",
",",
"conn",
")",
"\n",
"// Attach the tags to the packet and accept the packet",
"return",
"nil",
",",
"tcpPacket",
".",
"TCPDataAttach",
"(",
"tcpOptions",
",",
"tcpData",
")",
"\n",
"}"
] | // 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 traffic belongs to the same pu, let it go",
"if",
"conn",
".",
"GetState",
"(",
")",
"==",
"connection",
".",
"TCPData",
"&&",
"conn",
".",
"IsLoopbackConnection",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// 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",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"string",
"(",
"conn",
".",
"Auth",
".",
"LocalContext",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"tcpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"conn",
".",
"GetState",
"(",
")",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"err1",
":=",
"d",
".",
"netOrigConnectionTracker",
".",
"Remove",
"(",
"tcpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
")",
"\n",
"err2",
":=",
"d",
".",
"appReplyConnectionTracker",
".",
"Remove",
"(",
"tcpPacket",
".",
"L4FlowHash",
"(",
")",
")",
"\n\n",
"if",
"err1",
"!=",
"nil",
"||",
"err2",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// We now process packets that need authorization options",
"// Create TCP Option",
"tcpOptions",
":=",
"d",
".",
"createTCPAuthenticationOption",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"\n\n",
"claimsHeader",
":=",
"claimsheader",
".",
"NewClaimsHeader",
"(",
"claimsheader",
".",
"OptionEncrypt",
"(",
"conn",
".",
"PacketFlowPolicy",
".",
"Action",
".",
"Encrypted",
"(",
")",
")",
",",
")",
"\n\n",
"tcpData",
",",
"err",
":=",
"d",
".",
"tokenAccessor",
".",
"CreateSynAckPacketToken",
"(",
"context",
",",
"&",
"conn",
".",
"Auth",
",",
"claimsHeader",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Set the state for future reference",
"conn",
".",
"SetState",
"(",
"connection",
".",
"TCPSynAckSend",
")",
"\n\n",
"// Attach the tags to the packet",
"return",
"tcpPacket",
".",
"TCPDataAttach",
"(",
"tcpOptions",
",",
"tcpData",
")",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"claims",
"*",
"tokens",
".",
"ConnectionClaims",
",",
"err",
"error",
")",
"{",
"if",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"// Update connection state in the internal state machine tracker",
"switch",
"tcpPacket",
".",
"GetTCPFlags",
"(",
")",
"&",
"packet",
".",
"TCPSynAckMask",
"{",
"case",
"packet",
".",
"TCPSynMask",
":",
"return",
"d",
".",
"processNetworkSynPacket",
"(",
"context",
",",
"conn",
",",
"tcpPacket",
")",
"\n\n",
"case",
"packet",
".",
"TCPAckMask",
":",
"return",
"d",
".",
"processNetworkAckPacket",
"(",
"context",
",",
"conn",
",",
"tcpPacket",
")",
"\n\n",
"case",
"packet",
".",
"TCPSynAckMask",
":",
"return",
"d",
".",
"processNetworkSynAckPacket",
"(",
"context",
",",
"conn",
",",
"tcpPacket",
")",
"\n\n",
"default",
":",
"// Ignore any other packet",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // 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",
".",
"TCPAuthenticationOption",
",",
"enforcerconstants",
".",
"TCPAuthenticationOptionBaseLen",
"+",
"tokenLen",
",",
"0",
",",
"0",
"}",
"\n\n",
"if",
"tokenLen",
"!=",
"0",
"{",
"options",
"=",
"append",
"(",
"options",
",",
"token",
"...",
")",
"\n",
"}",
"\n\n",
"return",
"options",
"\n",
"}"
] | // 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",
",",
"p",
".",
"Mark",
",",
"p",
".",
"SourcePort",
"(",
")",
",",
"packet",
".",
"IPProtocolTCP",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"conn",
",",
"err",
":=",
"d",
".",
"appOrigConnectionTracker",
".",
"GetReset",
"(",
"p",
".",
"L4FlowHash",
"(",
")",
",",
"0",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"connection",
".",
"NewTCPConnection",
"(",
"context",
",",
"p",
")",
",",
"nil",
"\n",
"}"
] | // 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 is from Server, Did we see a network Syn for this server PU?",
"conn",
",",
"err",
":=",
"d",
".",
"appReplyConnectionTracker",
".",
"GetReset",
"(",
"hash",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"uerr",
":=",
"updateTimer",
"(",
"d",
".",
"appReplyConnectionTracker",
",",
"hash",
",",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
")",
";",
"uerr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"hash",
")",
")",
"\n",
"return",
"nil",
",",
"uerr",
"\n",
"}",
"\n\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"// If this ack packet is from client, Did we see an Application Syn packet before?",
"conn",
",",
"err",
"=",
"d",
".",
"appOrigConnectionTracker",
".",
"GetReset",
"(",
"hash",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"uerr",
":=",
"updateTimer",
"(",
"d",
".",
"appOrigConnectionTracker",
",",
"hash",
",",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
")",
";",
"uerr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"uerr",
"\n",
"}",
"\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"conn",
"=",
"connection",
".",
"NewTCPConnection",
"(",
"context",
",",
"p",
")",
"\n",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
".",
"SetState",
"(",
"connection",
".",
"UnknownState",
")",
"\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errNoConnFound",
"\n",
"}"
] | // 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",
",",
"p",
".",
"Mark",
",",
"p",
".",
"DestPort",
"(",
")",
",",
"packet",
".",
"IPProtocolTCP",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"conn",
",",
"err",
":=",
"d",
".",
"netOrigConnectionTracker",
".",
"GetReset",
"(",
"p",
".",
"L4FlowHash",
"(",
")",
",",
"0",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"connection",
".",
"NewTCPConnection",
"(",
"context",
",",
"p",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"//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",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"errNonPUTraffic",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"p",
".",
"TCPDataDetach",
"(",
"enforcerconstants",
".",
"TCPAuthenticationOptionBaseLen",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"errNonPUTraffic",
"\n",
"}",
"\n\n",
"p",
".",
"DropTCPDetachedBytes",
"(",
")",
"\n\n",
"p",
".",
"UpdateTCPChecksum",
"(",
")",
"\n\n",
"return",
"nil",
",",
"errNonPUTraffic",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errInvalidNetState",
"\n",
"}"
] | // 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",
".",
"GetReset",
"(",
"p",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeNetwork",
")",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errNonPUTraffic",
"\n",
"}",
"\n\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}"
] | // 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 network syn/ack packet? (PU is a client)",
"conn",
",",
"err",
":=",
"d",
".",
"netReplyConnectionTracker",
".",
"GetReset",
"(",
"hash",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"err",
"=",
"updateTimer",
"(",
"d",
".",
"netReplyConnectionTracker",
",",
"hash",
",",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"// Did we see a network Syn packet before? (PU is a server)",
"conn",
",",
"err",
"=",
"d",
".",
"netOrigConnectionTracker",
".",
"GetReset",
"(",
"hash",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"err",
"=",
"updateTimer",
"(",
"d",
".",
"netOrigConnectionTracker",
",",
"hash",
",",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"cerr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"conn",
"=",
"connection",
".",
"NewTCPConnection",
"(",
"context",
",",
"p",
")",
"\n",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
".",
"SetState",
"(",
"connection",
".",
"UnknownState",
")",
"\n",
"return",
"conn",
".",
"(",
"*",
"connection",
".",
"TCPConnection",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errInvalidNetState",
"\n",
"}"
] | // 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",
"conn",
".",
"ServiceConnection",
"&&",
"conn",
".",
"TimeOut",
">",
"0",
"{",
"return",
"c",
".",
"SetTimeOut",
"(",
"hash",
",",
"conn",
".",
"TimeOut",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
")",
"{",
"if",
"err",
":=",
"d",
".",
"appOrigConnectionTracker",
".",
"Remove",
"(",
"tcpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"sourcePortConnectionCache",
".",
"Remove",
"(",
"tcpPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeNetwork",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"conntrack",
".",
"UpdateNetworkFlowMark",
"(",
"tcpPacket",
".",
"SourceAddress",
"(",
")",
",",
"tcpPacket",
".",
"DestinationAddress",
"(",
")",
",",
"tcpPacket",
".",
"IPProto",
"(",
")",
",",
"tcpPacket",
".",
"SourcePort",
"(",
")",
",",
"tcpPacket",
".",
"DestPort",
"(",
")",
",",
"constants",
".",
"DefaultConnMark",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"tcpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"d",
".",
"reportReverseExternalServiceFlow",
"(",
"context",
",",
"report",
",",
"action",
",",
"true",
",",
"tcpPacket",
")",
"\n",
"}"
] | // 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",
".",
"L4FlowHash",
"(",
")",
")",
")",
"\n",
"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",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
",",
"puInfo",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSupervisor",
")",
"(",
"nil",
")",
".",
"Supervise",
")",
",",
"contextID",
",",
"puInfo",
")",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"version",
",",
"contextID",
",",
"containerInfo",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockImplementor",
")",
"(",
"nil",
")",
".",
"ConfigureRules",
")",
",",
"version",
",",
"contextID",
",",
"containerInfo",
")",
"\n",
"}"
] | // 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",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"version",
",",
"context",
",",
"tcpPorts",
",",
"udpPorts",
",",
"mark",
",",
"uid",
",",
"proxyPort",
",",
"puType",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockImplementor",
")",
"(",
"nil",
")",
".",
"DeleteRules",
")",
",",
"version",
",",
"context",
",",
"tcpPorts",
",",
"udpPorts",
",",
"mark",
",",
"uid",
",",
"proxyPort",
",",
"puType",
")",
"\n",
"}"
] | // 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",
".",
"IptablesProvider",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"address",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"EventServer",
"{",
"socketPath",
":",
"address",
",",
"registerer",
":",
"registerer",
",",
"}",
",",
"nil",
"\n",
"}"
] | // 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 listener",
"addr",
",",
"_",
":=",
"net",
".",
"ResolveUnixAddr",
"(",
"\"",
"\"",
",",
"e",
".",
"socketPath",
")",
"\n",
"nl",
",",
"err",
":=",
"net",
".",
"ListenUnix",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"listener",
":=",
"&",
"UIDListener",
"{",
"nl",
"}",
"\n\n",
"// Start serving HTTP requests in the background",
"go",
"e",
".",
"server",
".",
"Serve",
"(",
"listener",
")",
"// nolint",
"\n\n",
"// Listen for context cancellation to close the socket.",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"nl",
".",
"Close",
"(",
")",
"// nolint",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
"// nolint",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
".",
"Decode",
"(",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusBadRequest",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateTypes",
"(",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
",",
"http",
".",
"StatusBadRequest",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateUser",
"(",
"r",
",",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
",",
"http",
".",
"StatusForbidden",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateEvent",
"(",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
",",
"http",
".",
"StatusBadRequest",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"e",
".",
"processEvent",
"(",
"r",
".",
"Context",
"(",
")",
",",
"event",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
"zap",
".",
"Reflect",
"(",
"\"",
"\"",
",",
"event",
")",
")",
"\n",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusAccepted",
")",
"\n",
"}"
] | // 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",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"e",
".",
"registerer",
".",
"GetHandler",
"(",
"eventInfo",
".",
"PUType",
",",
"eventInfo",
".",
"EventType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"f",
"(",
"ctx",
",",
"eventInfo",
")",
"\n",
"}"
] | // 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",
"if",
"len",
"(",
"parts",
")",
"!=",
"3",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Accept all requests from root users",
"if",
"parts",
"[",
"0",
"]",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// The target process must be valid.",
"p",
",",
"err",
":=",
"process",
".",
"NewProcess",
"(",
"event",
".",
"PID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// The UID of the calling process must match the UID of the target process.",
"uids",
",",
"err",
":=",
"p",
".",
"Uids",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"match",
":=",
"false",
"\n",
"for",
"_",
",",
"uid",
":=",
"range",
"uids",
"{",
"if",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"uid",
")",
")",
"==",
"parts",
"[",
"0",
"]",
"{",
"match",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"match",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
",",
"parts",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\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",
"regexCgroup",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"common",
".",
"EventMap",
"[",
"event",
".",
"EventType",
"]",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"event",
".",
"EventType",
")",
")",
"\n",
"}",
"\n\n",
"if",
"event",
".",
"PUType",
">",
"common",
".",
"TransientPU",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
".",
"PUType",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"regexStrings",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"event",
".",
"Name",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"event",
".",
"Cgroup",
")",
">",
"0",
"&&",
"!",
"regexCgroup",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"event",
".",
"Cgroup",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
".",
"Cgroup",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"regexNS",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"event",
".",
"NS",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"event",
".",
"IPs",
"{",
"if",
"!",
"regexStrings",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"k",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"k",
")",
"\n",
"}",
"\n\n",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"v",
")",
";",
"ip",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"HostService",
"{",
"if",
"event",
".",
"NetworkOnlyTraffic",
"{",
"if",
"event",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"event",
".",
"PUID",
"==",
"\"",
"\"",
"{",
"event",
".",
"PUID",
"=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"event",
".",
"PID",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"event",
".",
"EventType",
"==",
"common",
".",
"EventStop",
"||",
"event",
".",
"EventType",
"==",
"common",
".",
"EventDestroy",
"{",
"regStop",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
")",
"\n",
"if",
"event",
".",
"Cgroup",
"!=",
"\"",
"\"",
"&&",
"!",
"regStop",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"event",
".",
"Cgroup",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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\n",
"username",
":=",
"puInfo",
".",
"Runtime",
".",
"Options",
"(",
")",
".",
"UserID",
"\n",
"prefix",
":=",
"\"",
"\"",
"\n\n",
"if",
"username",
"!=",
"\"",
"\"",
"{",
"prefix",
"=",
"uidPortSetPrefix",
"\n",
"}",
"else",
"{",
"prefix",
"=",
"processPortSetPrefix",
"\n",
"}",
"\n\n",
"portSetName",
":=",
"puPortSetName",
"(",
"contextID",
",",
"prefix",
")",
"\n\n",
"if",
"puseterr",
":=",
"i",
".",
"createPUPortSet",
"(",
"portSetName",
")",
";",
"puseterr",
"!=",
"nil",
"{",
"return",
"puseterr",
"\n",
"}",
"\n\n",
"i",
".",
"contextIDToPortSetMap",
".",
"AddOrUpdate",
"(",
"contextID",
",",
"portSetName",
")",
"\n",
"return",
"nil",
"\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",
"(",
"contextID",
")",
"\n",
"if",
"portSetName",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ips",
":=",
"ipset",
".",
"IPSet",
"{",
"Name",
":",
"portSetName",
",",
"}",
"\n\n",
"if",
"err",
":=",
"ips",
".",
"Destroy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"portSetName",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"contextIDToPortSetMap",
".",
"Remove",
"(",
"contextID",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"contextID",
")",
"\n",
"}",
"\n\n",
"ips",
":=",
"ipset",
".",
"IPSet",
"{",
"Name",
":",
"portSetName",
",",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"ips",
".",
"Del",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"UserRecord",
"{",
"}",
",",
"ProcessedUsers",
":",
"map",
"[",
"string",
"]",
"bool",
"{",
"}",
",",
"DatapathPacketReports",
":",
"[",
"]",
"*",
"collector",
".",
"PacketReport",
"{",
"}",
",",
"}",
"\n",
"}"
] | // 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",
"tags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
",",
"info",
".",
"Config",
".",
"Image",
")",
"\n",
"tags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
",",
"info",
".",
"Name",
")",
"\n",
"tags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
",",
"info",
".",
"Config",
".",
"Image",
")",
"\n",
"tags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"tags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
",",
"info",
".",
"Name",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"info",
".",
"Config",
".",
"Labels",
"{",
"if",
"len",
"(",
"strings",
".",
"TrimSpace",
"(",
"k",
")",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"value",
":=",
"v",
"\n",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"value",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"k",
",",
"UserLabelPrefix",
")",
"{",
"tags",
".",
"AppendKeyValue",
"(",
"UserLabelPrefix",
"+",
"k",
",",
"value",
")",
"\n",
"}",
"else",
"{",
"tags",
".",
"AppendKeyValue",
"(",
"k",
",",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"ipa",
":=",
"policy",
".",
"ExtendedMap",
"{",
"\"",
"\"",
":",
"info",
".",
"NetworkSettings",
".",
"IPAddress",
",",
"}",
"\n\n",
"if",
"info",
".",
"HostConfig",
".",
"NetworkMode",
"==",
"constants",
".",
"DockerHostMode",
"{",
"return",
"policy",
".",
"NewPURuntime",
"(",
"info",
".",
"Name",
",",
"info",
".",
"State",
".",
"Pid",
",",
"\"",
"\"",
",",
"tags",
",",
"ipa",
",",
"common",
".",
"LinuxProcessPU",
",",
"hostModeOptions",
"(",
"info",
")",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"policy",
".",
"NewPURuntime",
"(",
"info",
".",
"Name",
",",
"info",
".",
"State",
".",
"Pid",
",",
"\"",
"\"",
",",
"tags",
",",
"ipa",
",",
"common",
".",
"ContainerPU",
",",
"nil",
")",
",",
"nil",
"\n",
"}"
] | // 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",
".",
"Pid",
")",
",",
"CgroupMark",
":",
"strconv",
".",
"FormatUint",
"(",
"cgnetcls",
".",
"MarkVal",
"(",
")",
",",
"10",
")",
",",
"}",
"\n\n",
"for",
"p",
":=",
"range",
"dockerInfo",
".",
"Config",
".",
"ExposedPorts",
"{",
"if",
"p",
".",
"Proto",
"(",
")",
"==",
"\"",
"\"",
"{",
"s",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"p",
".",
"Port",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"options",
".",
"Services",
"=",
"append",
"(",
"options",
".",
"Services",
",",
"common",
".",
"Service",
"{",
"Protocol",
":",
"uint8",
"(",
"6",
")",
",",
"Ports",
":",
"s",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"options",
"\n",
"}"
] | // 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",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"Destination",
".",
"ID",
")",
")",
"// nolint errcheck",
"\n",
"port",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"port",
",",
"r",
".",
"Destination",
".",
"Port",
")",
"\n",
"hash",
".",
"Write",
"(",
"port",
")",
"// nolint errcheck",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"Action",
".",
"String",
"(",
")",
")",
")",
"// nolint errcheck",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"ObservedAction",
".",
"String",
"(",
")",
")",
")",
"// nolint errcheck",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"DropReason",
")",
")",
"// nolint errcheck",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"Destination",
".",
"URI",
")",
")",
"// nolint errcheck",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"hash",
".",
"Sum64",
"(",
")",
")",
"\n",
"}"
] | // 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",
";",
"i",
"<",
"len",
"(",
"r",
".",
"Claims",
")",
";",
"i",
"++",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"r",
".",
"Claims",
"[",
"i",
"]",
",",
"\"",
"\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"Claims",
"[",
"i",
"]",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"ID",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"hash",
".",
"Sum64",
"(",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"}",
"\n",
"}"
] | // 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",
"}",
"else",
"{",
"// Remove the range if it exists",
"p",
".",
"Remove",
"(",
"s",
")",
"// nolint",
"\n",
"// Insert the portspec",
"p",
".",
"Lock",
"(",
")",
"\n",
"p",
".",
"ranges",
"=",
"append",
"(",
"[",
"]",
"*",
"portspec",
".",
"PortSpec",
"{",
"s",
"}",
",",
"p",
".",
"ranges",
"...",
")",
"\n",
"p",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\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",
".",
"ranges",
"=",
"append",
"(",
"p",
".",
"ranges",
",",
"s",
")",
"\n",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"}"
] | // 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",
"{",
"if",
"err",
",",
"_",
":=",
"p",
".",
"ports",
".",
"Get",
"(",
"s",
".",
"Min",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"r",
":=",
"range",
"p",
".",
"ranges",
"{",
"if",
"r",
".",
"Max",
"<=",
"s",
".",
"Min",
"||",
"r",
".",
"Min",
">=",
"s",
".",
"Max",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"Max",
",",
"r",
".",
"Min",
")",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"Min",
"==",
"s",
".",
"Max",
"{",
"return",
"p",
".",
"ports",
".",
"Add",
"(",
"s",
".",
"Min",
",",
"s",
")",
"\n",
"}",
"\n\n",
"p",
".",
"ranges",
"=",
"append",
"(",
"p",
".",
"ranges",
",",
"s",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"==",
"nil",
"{",
"return",
"spec",
".",
"(",
"*",
"portspec",
".",
"PortSpec",
")",
".",
"Value",
"(",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"p",
".",
"ranges",
"{",
"if",
"s",
".",
"Min",
"<=",
"port",
"&&",
"port",
"<",
"s",
".",
"Max",
"{",
"return",
"s",
".",
"Value",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"port",
")",
"\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",
"multiple",
"intervals",
"that",
"match",
"it",
"will",
"randomly",
"return",
"one",
"of",
"them",
"."
] | 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",
"}",
"\n\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"for",
"i",
",",
"r",
":=",
"range",
"p",
".",
"ranges",
"{",
"if",
"r",
".",
"Min",
"==",
"s",
".",
"Min",
"&&",
"r",
".",
"Max",
"==",
"s",
".",
"Max",
"{",
"left",
":=",
"p",
".",
"ranges",
"[",
":",
"i",
"]",
"\n",
"right",
":=",
"p",
".",
"ranges",
"[",
"i",
"+",
"1",
":",
"]",
"\n",
"p",
".",
"ranges",
"=",
"append",
"(",
"left",
",",
"right",
"...",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\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",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"Remove",
"(",
"s",
")",
"\n",
"}"
] | // 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",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"req",
",",
"resp",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRemoteIntf",
")",
"(",
"nil",
")",
".",
"InitEnforcer",
")",
",",
"req",
",",
"resp",
")",
"\n",
"}"
] | // 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",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"transport",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"transport",
".",
"Run",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"secrets",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"secrets",
".",
"Run",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
"contextID",
",",
"puInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"proxy",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"proxy",
".",
"Enforce",
"(",
"context",
".",
"Background",
"(",
")",
",",
"contextID",
",",
"puInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"secrets",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"secrets",
".",
"Enforce",
"(",
"puInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"Unenforce",
"(",
"context",
".",
"Background",
"(",
")",
",",
"contextID",
")",
";",
"perr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"perr",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"transport",
"!=",
"nil",
"{",
"if",
"nerr",
"=",
"e",
".",
"transport",
".",
"Unenforce",
"(",
"contextID",
")",
";",
"nerr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"nerr",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"secrets",
"!=",
"nil",
"{",
"if",
"serr",
"=",
"e",
".",
"secrets",
".",
"Unenforce",
"(",
"contextID",
")",
";",
"nerr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"nerr",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"perr",
"!=",
"nil",
"||",
"nerr",
"!=",
"nil",
"||",
"serr",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"perr",
",",
"nerr",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"transport",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"transport",
".",
"UpdateSecrets",
"(",
"secrets",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"secrets",
"!=",
"nil",
"{",
"if",
"err",
":=",
"e",
".",
"secrets",
".",
"UpdateSecrets",
"(",
"secrets",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"EnableDatapathPacketTracing",
"(",
"contextID",
",",
"direction",
",",
"interval",
")",
"\n\n",
"}"
] | // 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",
",",
"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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"puFromContextID",
":=",
"cache",
".",
"NewCache",
"(",
"\"",
"\"",
")",
"\n\n",
"transport",
":=",
"nfqdatapath",
".",
"New",
"(",
"mutualAuthorization",
",",
"fqConfig",
",",
"collector",
",",
"serverID",
",",
"validity",
",",
"service",
",",
"secrets",
",",
"mode",
",",
"procMountPoint",
",",
"externalIPCacheTimeout",
",",
"packetLogs",
",",
"tokenAccessor",
",",
"puFromContextID",
",",
"cfg",
",",
")",
"\n\n",
"tcpProxy",
",",
"err",
":=",
"applicationproxy",
".",
"NewAppProxy",
"(",
"tokenAccessor",
",",
"collector",
",",
"puFromContextID",
",",
"nil",
",",
"secrets",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"enforcer",
"{",
"proxy",
":",
"tcpProxy",
",",
"transport",
":",
"transport",
",",
"secrets",
":",
"secretsproxy",
".",
"NewSecretsProxy",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // 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",
"default",
":",
"return",
"compressionTypeNoneMask",
"\n",
"}",
"\n",
"}"
] | // 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",
"default",
":",
"return",
"CompressionTypeNone",
"\n",
"}",
"\n",
"}"
] | // 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",
"(",
")",
":",
"return",
"CompressionTypeV2",
"\n",
"default",
":",
"return",
"CompressionTypeNone",
"\n",
"}",
"\n",
"}"
] | // 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",
",",
"nodeName",
"string",
",",
"enableHostPods",
"bool",
")",
"*",
"ReconcilePod",
"{",
"return",
"&",
"ReconcilePod",
"{",
"client",
":",
"mgr",
".",
"GetClient",
"(",
")",
",",
"scheme",
":",
"mgr",
".",
"GetScheme",
"(",
")",
",",
"recorder",
":",
"mgr",
".",
"GetRecorder",
"(",
"\"",
"\"",
")",
",",
"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",
",",
"}",
"\n",
"}"
] | // 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",
"(",
"\"",
"\"",
",",
"mgr",
",",
"controller",
".",
"Options",
"{",
"Reconciler",
":",
"r",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// we use this mapper in both of our event sources",
"mapper",
":=",
"&",
"WatchPodMapper",
"{",
"client",
":",
"mgr",
".",
"GetClient",
"(",
")",
",",
"nodeName",
":",
"r",
".",
"nodeName",
",",
"enableHostPods",
":",
"r",
".",
"enableHostPods",
",",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
",",
"trustedCertificate",
")",
",",
"}",
"\n",
"}"
] | // 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",
"validate",
"tokens",
".",
"If",
"the",
"list",
"is",
"empty",
"the",
"CA",
"from",
"the",
"secrets",
"will",
"be",
"used",
"for",
"token",
"validation",
"."
] | 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",
"]",
"string",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"apis",
"=",
"apis",
"\n",
"p",
".",
"userTokenMappings",
"=",
"mappings",
"\n",
"p",
".",
"userTokenHandler",
"=",
"handler",
"\n",
"p",
".",
"userAuthorizationType",
"=",
"serviceType",
"\n",
"}"
] | // 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",
"return",
"nil",
"\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",
",",
"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",
"{",
"}",
"\n",
"for",
"_",
",",
"cert",
":=",
"range",
"certs",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"\"",
"\"",
"+",
"cert",
".",
"Subject",
".",
"CommonName",
")",
"\n",
"for",
"_",
",",
"email",
":=",
"range",
"cert",
".",
"EmailAddresses",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"\"",
"\"",
"+",
"email",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"org",
":=",
"range",
"cert",
".",
"Subject",
".",
"Organization",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"\"",
"\"",
"+",
"org",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"org",
":=",
"range",
"cert",
".",
"Subject",
".",
"OrganizationalUnit",
"{",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"\"",
"\"",
"+",
"org",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"p",
".",
"userAuthorizationType",
"==",
"policy",
".",
"UserAuthorizationJWT",
"&&",
"p",
".",
"userTokenHandler",
"!=",
"nil",
"{",
"jwtAttributes",
",",
"_",
",",
"_",
",",
"err",
":=",
"p",
".",
"userTokenHandler",
".",
"Validate",
"(",
"r",
".",
"Context",
"(",
")",
",",
"userToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"attributes",
",",
"false",
",",
"userToken",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"attributes",
"=",
"append",
"(",
"attributes",
",",
"jwtAttributes",
"...",
")",
"\n",
"}",
"\n\n",
"return",
"attributes",
",",
"false",
",",
"userToken",
",",
"nil",
"\n\n",
"case",
"policy",
".",
"UserAuthorizationOIDC",
":",
"// Now we can parse the user claims.",
"if",
"p",
".",
"userTokenHandler",
"==",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"return",
"[",
"]",
"string",
"{",
"}",
",",
"false",
",",
"userToken",
",",
"nil",
"\n",
"}",
"\n",
"return",
"p",
".",
"userTokenHandler",
".",
"Validate",
"(",
"r",
".",
"Context",
"(",
")",
",",
"userToken",
")",
"\n",
"default",
":",
"return",
"[",
"]",
"string",
"{",
"}",
",",
"false",
",",
"userToken",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // 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",
".",
"aporetoJWT",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"// Finally we can parse the Aporeto token.",
"id",
",",
"scopes",
",",
"profile",
",",
"err",
":=",
"p",
".",
"aporetoJWT",
".",
"ParseToken",
"(",
"aporetoToken",
",",
"publicKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"id",
",",
"append",
"(",
"profile",
",",
"scopes",
"...",
")",
",",
"nil",
"\n",
"}"
] | // 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 token through the handler.",
"token",
",",
"originURL",
",",
"status",
",",
"err",
":=",
"p",
".",
"userTokenHandler",
".",
"Callback",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"cookie",
":=",
"&",
"http",
".",
"Cookie",
"{",
"Name",
":",
"\"",
"\"",
",",
"Value",
":",
"token",
",",
"HttpOnly",
":",
"true",
",",
"Secure",
":",
"true",
",",
"Path",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"http",
".",
"SetCookie",
"(",
"w",
",",
"cookie",
")",
"\n\n",
"// We transmit the information in the return payload for applications",
"// that choose to use it directly without a cookie.",
"data",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"cookie",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// We redirect here to the original URL that the application attempted",
"// to access.",
"w",
".",
"Header",
"(",
")",
".",
"Add",
"(",
"\"",
"\"",
",",
"originURL",
")",
"\n",
"http",
".",
"Error",
"(",
"w",
",",
"string",
"(",
"data",
")",
",",
"status",
")",
"\n",
"}"
] | // 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",
"return",
"p",
".",
"apis",
".",
"FindAndMatchScope",
"(",
"method",
",",
"uri",
",",
"claims",
")",
"\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",
"the",
"access",
"public",
"or",
"not",
".",
"This",
"allows",
"callers",
"to",
"decide",
"what",
"to",
"do",
"when",
"there",
"is",
"a",
"failure",
"and",
"potentially",
"issue",
"a",
"redirect",
"."
] | 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",
"(",
"originURL",
")",
"\n",
"}"
] | // 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",
"(",
"p",
".",
"userTokenMappings",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"claim",
":=",
"range",
"claims",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"claim",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"header",
",",
"ok",
":=",
"p",
".",
"userTokenMappings",
"[",
"parts",
"[",
"0",
"]",
"]",
";",
"ok",
"&&",
"len",
"(",
"parts",
")",
"==",
"2",
"{",
"r",
".",
"Header",
".",
"Add",
"(",
"header",
",",
"parts",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // 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",
",",
"DefaultQueueSize",
",",
")",
"\n",
"}"
] | // 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",
"\n",
"}",
"\n",
"<-",
"time",
".",
"After",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"n",
".",
"nfqStr",
"=",
"string",
"(",
"data",
")",
"\n\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"bytes",
".",
"NewReader",
"(",
"data",
")",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"line",
":=",
"scanner",
".",
"Text",
"(",
")",
"\n",
"lineParts",
":=",
"strings",
".",
"Fields",
"(",
"line",
")",
"\n",
"newNFQ",
":=",
"makeNFQLayout",
"(",
"lineParts",
")",
"\n\n",
"n",
".",
"contents",
"[",
"newNFQ",
".",
"QueueNum",
"]",
"=",
"newNFQ",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"[",
"queueNum",
"]",
"\n",
"if",
"ok",
"{",
"return",
"&",
"content",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
",",
"eventInfo",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockProcessor",
")",
"(",
"nil",
")",
".",
"Start",
")",
",",
"ctx",
",",
"eventInfo",
")",
"\n",
"}"
] | // 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",
"k",
",",
"v",
":=",
"range",
"tags",
"{",
"t",
".",
"Tags",
"[",
"i",
"]",
"=",
"k",
"+",
"\"",
"\"",
"+",
"v",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // 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",
"&",
"TagStore",
"{",
"c",
"}",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"key",
"==",
"parts",
"[",
"0",
"]",
"{",
"return",
"parts",
"[",
"1",
"]",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"t",
".",
"Get",
"(",
"parts",
"[",
"0",
"]",
")",
";",
"!",
"ok",
"{",
"t",
".",
"AppendKeyValue",
"(",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"1",
"]",
")",
"\n",
"merged",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"merged",
"\n",
"}"
] | // 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"res",
"==",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"data",
":=",
"req",
".",
"Context",
"(",
")",
".",
"Value",
"(",
"statsContextKey",
")",
"\n",
"if",
"data",
"==",
"nil",
"{",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n\n",
"state",
",",
"ok",
":=",
"data",
".",
"(",
"*",
"connectionState",
")",
"\n",
"if",
"ok",
"&&",
"state",
".",
"cookie",
"==",
"nil",
"{",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"v",
":=",
"state",
".",
"cookie",
".",
"String",
"(",
")",
";",
"v",
"!=",
"\"",
"\"",
"{",
"res",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // 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",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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.