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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,800 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | NewRPCClient | func (mr *MockRPCClientMockRecorder) NewRPCClient(contextID, channel, rpcSecret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRPCClient", reflect.TypeOf((*MockRPCClient)(nil).NewRPCClient), contextID, channel, rpcSecret)
} | go | func (mr *MockRPCClientMockRecorder) NewRPCClient(contextID, channel, rpcSecret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRPCClient", reflect.TypeOf((*MockRPCClient)(nil).NewRPCClient), contextID, channel, rpcSecret)
} | [
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"NewRPCClient",
"(",
"contextID",
",",
"channel",
",",
"rpcSecret",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodTyp... | // NewRPCClient indicates an expected call of NewRPCClient
// nolint | [
"NewRPCClient",
"indicates",
"an",
"expected",
"call",
"of",
"NewRPCClient",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L52-L54 |
6,801 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | GetRPCClient | func (m *MockRPCClient) GetRPCClient(contextID string) (*rpcwrapper.RPCHdl, error) {
ret := m.ctrl.Call(m, "GetRPCClient", contextID)
ret0, _ := ret[0].(*rpcwrapper.RPCHdl)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockRPCClient) GetRPCClient(contextID string) (*rpcwrapper.RPCHdl, error) {
ret := m.ctrl.Call(m, "GetRPCClient", contextID)
ret0, _ := ret[0].(*rpcwrapper.RPCHdl)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"GetRPCClient",
"(",
"contextID",
"string",
")",
"(",
"*",
"rpcwrapper",
".",
"RPCHdl",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
")... | // GetRPCClient mocks base method
// nolint | [
"GetRPCClient",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L58-L63 |
6,802 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | RemoteCall | func (m *MockRPCClient) RemoteCall(contextID, methodName string, req *rpcwrapper.Request, resp *rpcwrapper.Response) error {
ret := m.ctrl.Call(m, "RemoteCall", contextID, methodName, req, resp)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRPCClient) RemoteCall(contextID, methodName string, req *rpcwrapper.Request, resp *rpcwrapper.Response) error {
ret := m.ctrl.Call(m, "RemoteCall", contextID, methodName, req, resp)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"RemoteCall",
"(",
"contextID",
",",
"methodName",
"string",
",",
"req",
"*",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
... | // RemoteCall mocks base method
// nolint | [
"RemoteCall",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L73-L77 |
6,803 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | RemoteCall | func (mr *MockRPCClientMockRecorder) RemoteCall(contextID, methodName, req, resp interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteCall", reflect.TypeOf((*MockRPCClient)(nil).RemoteCall), contextID, methodName, req, resp)
} | go | func (mr *MockRPCClientMockRecorder) RemoteCall(contextID, methodName, req, resp interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteCall", reflect.TypeOf((*MockRPCClient)(nil).RemoteCall), contextID, methodName, req, resp)
} | [
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"RemoteCall",
"(",
"contextID",
",",
"methodName",
",",
"req",
",",
"resp",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallW... | // RemoteCall indicates an expected call of RemoteCall
// nolint | [
"RemoteCall",
"indicates",
"an",
"expected",
"call",
"of",
"RemoteCall",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L81-L83 |
6,804 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | DestroyRPCClient | func (m *MockRPCClient) DestroyRPCClient(contextID string) {
m.ctrl.Call(m, "DestroyRPCClient", contextID)
} | go | func (m *MockRPCClient) DestroyRPCClient(contextID string) {
m.ctrl.Call(m, "DestroyRPCClient", contextID)
} | [
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"DestroyRPCClient",
"(",
"contextID",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
")",
"\n",
"}"
] | // DestroyRPCClient mocks base method
// nolint | [
"DestroyRPCClient",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L87-L89 |
6,805 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | DestroyRPCClient | func (mr *MockRPCClientMockRecorder) DestroyRPCClient(contextID interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyRPCClient", reflect.TypeOf((*MockRPCClient)(nil).DestroyRPCClient), contextID)
} | go | func (mr *MockRPCClientMockRecorder) DestroyRPCClient(contextID interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyRPCClient", reflect.TypeOf((*MockRPCClient)(nil).DestroyRPCClient), contextID)
} | [
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"DestroyRPCClient",
"(",
"contextID",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
... | // DestroyRPCClient indicates an expected call of DestroyRPCClient
// nolint | [
"DestroyRPCClient",
"indicates",
"an",
"expected",
"call",
"of",
"DestroyRPCClient",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L93-L95 |
6,806 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | ContextList | func (m *MockRPCClient) ContextList() []string {
ret := m.ctrl.Call(m, "ContextList")
ret0, _ := ret[0].([]string)
return ret0
} | go | func (m *MockRPCClient) ContextList() []string {
ret := m.ctrl.Call(m, "ContextList")
ret0, _ := ret[0].([]string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"ContextList",
"(",
")",
"[",
"]",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]... | // ContextList mocks base method
// nolint | [
"ContextList",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L99-L103 |
6,807 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | CheckValidity | func (mr *MockRPCClientMockRecorder) CheckValidity(req, secret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckValidity", reflect.TypeOf((*MockRPCClient)(nil).CheckValidity), req, secret)
} | go | func (mr *MockRPCClientMockRecorder) CheckValidity(req, secret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckValidity", reflect.TypeOf((*MockRPCClient)(nil).CheckValidity), req, secret)
} | [
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"CheckValidity",
"(",
"req",
",",
"secret",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
... | // CheckValidity indicates an expected call of CheckValidity
// nolint | [
"CheckValidity",
"indicates",
"an",
"expected",
"call",
"of",
"CheckValidity",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L121-L123 |
6,808 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | StartServer | func (m *MockRPCServer) StartServer(ctx context.Context, protocol, path string, handler interface{}) error {
ret := m.ctrl.Call(m, "StartServer", ctx, protocol, path, handler)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRPCServer) StartServer(ctx context.Context, protocol, path string, handler interface{}) error {
ret := m.ctrl.Call(m, "StartServer", ctx, protocol, path, handler)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCServer",
")",
"StartServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"protocol",
",",
"path",
"string",
",",
"handler",
"interface",
"{",
"}",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",... | // StartServer mocks base method
// nolint | [
"StartServer",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L154-L158 |
6,809 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | StartServer | func (mr *MockRPCServerMockRecorder) StartServer(ctx, protocol, path, handler interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartServer", reflect.TypeOf((*MockRPCServer)(nil).StartServer), ctx, protocol, path, handler)
} | go | func (mr *MockRPCServerMockRecorder) StartServer(ctx, protocol, path, handler interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartServer", reflect.TypeOf((*MockRPCServer)(nil).StartServer), ctx, protocol, path, handler)
} | [
"func",
"(",
"mr",
"*",
"MockRPCServerMockRecorder",
")",
"StartServer",
"(",
"ctx",
",",
"protocol",
",",
"path",
",",
"handler",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWith... | // StartServer indicates an expected call of StartServer
// nolint | [
"StartServer",
"indicates",
"an",
"expected",
"call",
"of",
"StartServer",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L162-L164 |
6,810 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | ProcessMessage | func (mr *MockRPCServerMockRecorder) ProcessMessage(req, secret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessMessage", reflect.TypeOf((*MockRPCServer)(nil).ProcessMessage), req, secret)
} | go | func (mr *MockRPCServerMockRecorder) ProcessMessage(req, secret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessMessage", reflect.TypeOf((*MockRPCServer)(nil).ProcessMessage), req, secret)
} | [
"func",
"(",
"mr",
"*",
"MockRPCServerMockRecorder",
")",
"ProcessMessage",
"(",
"req",
",",
"secret",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
... | // ProcessMessage indicates an expected call of ProcessMessage
// nolint | [
"ProcessMessage",
"indicates",
"an",
"expected",
"call",
"of",
"ProcessMessage",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L176-L178 |
6,811 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | CheckValidity | func (m *MockRPCServer) CheckValidity(req *rpcwrapper.Request, secret string) bool {
ret := m.ctrl.Call(m, "CheckValidity", req, secret)
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockRPCServer) CheckValidity(req *rpcwrapper.Request, secret string) bool {
ret := m.ctrl.Call(m, "CheckValidity", req, secret)
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCServer",
")",
"CheckValidity",
"(",
"req",
"*",
"rpcwrapper",
".",
"Request",
",",
"secret",
"string",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"req",
",",
"secret"... | // CheckValidity mocks base method
// nolint | [
"CheckValidity",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L182-L186 |
6,812 | aporeto-inc/trireme-lib | monitor/internal/pod/watcher.go | Map | func (w *WatchPodMapper) Map(obj handler.MapObject) []reconcile.Request {
pod, ok := obj.Object.(*corev1.Pod)
if !ok {
return nil
}
if pod.Spec.NodeName != w.nodeName {
return nil
}
if pod.Spec.HostNetwork && !w.enableHostPods {
return nil
}
return []reconcile.Request{
{
NamespacedName: types.NamespacedName{
Name: pod.Name,
Namespace: pod.Namespace,
},
},
}
} | go | func (w *WatchPodMapper) Map(obj handler.MapObject) []reconcile.Request {
pod, ok := obj.Object.(*corev1.Pod)
if !ok {
return nil
}
if pod.Spec.NodeName != w.nodeName {
return nil
}
if pod.Spec.HostNetwork && !w.enableHostPods {
return nil
}
return []reconcile.Request{
{
NamespacedName: types.NamespacedName{
Name: pod.Name,
Namespace: pod.Namespace,
},
},
}
} | [
"func",
"(",
"w",
"*",
"WatchPodMapper",
")",
"Map",
"(",
"obj",
"handler",
".",
"MapObject",
")",
"[",
"]",
"reconcile",
".",
"Request",
"{",
"pod",
",",
"ok",
":=",
"obj",
".",
"Object",
".",
"(",
"*",
"corev1",
".",
"Pod",
")",
"\n",
"if",
"!"... | // Map implements the handler.Mapper interface to emit reconciles for corev1.Pods. It effectively
// filters the pods by looking for a matching nodeName and filters them out if host networking is requested,
// but we don't want to enable those. | [
"Map",
"implements",
"the",
"handler",
".",
"Mapper",
"interface",
"to",
"emit",
"reconciles",
"for",
"corev1",
".",
"Pods",
".",
"It",
"effectively",
"filters",
"the",
"pods",
"by",
"looking",
"for",
"a",
"matching",
"nodeName",
"and",
"filters",
"them",
"o... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/pod/watcher.go#L23-L45 |
6,813 | aporeto-inc/trireme-lib | controller/pkg/pkiverifier/pkiverifier.go | NewPKIIssuer | func NewPKIIssuer(privateKey *ecdsa.PrivateKey) PKITokenIssuer {
return &tokenManager{
privateKey: privateKey,
signMethod: jwt.SigningMethodES256,
}
} | go | func NewPKIIssuer(privateKey *ecdsa.PrivateKey) PKITokenIssuer {
return &tokenManager{
privateKey: privateKey,
signMethod: jwt.SigningMethodES256,
}
} | [
"func",
"NewPKIIssuer",
"(",
"privateKey",
"*",
"ecdsa",
".",
"PrivateKey",
")",
"PKITokenIssuer",
"{",
"return",
"&",
"tokenManager",
"{",
"privateKey",
":",
"privateKey",
",",
"signMethod",
":",
"jwt",
".",
"SigningMethodES256",
",",
"}",
"\n",
"}"
] | // NewPKIIssuer initializes a new signer structure | [
"NewPKIIssuer",
"initializes",
"a",
"new",
"signer",
"structure"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pkiverifier/pkiverifier.go#L52-L58 |
6,814 | aporeto-inc/trireme-lib | controller/pkg/pkiverifier/pkiverifier.go | NewPKIVerifier | func NewPKIVerifier(publicKeys []*ecdsa.PublicKey, cacheValidity time.Duration) PKITokenVerifier {
validity := defaultValidity * time.Second
if cacheValidity > 0 {
validity = cacheValidity
}
return &tokenManager{
publicKeys: publicKeys,
signMethod: jwt.SigningMethodES256,
keycache: cache.NewCacheWithExpiration("PKIVerifierKey", validity),
validity: validity,
}
} | go | func NewPKIVerifier(publicKeys []*ecdsa.PublicKey, cacheValidity time.Duration) PKITokenVerifier {
validity := defaultValidity * time.Second
if cacheValidity > 0 {
validity = cacheValidity
}
return &tokenManager{
publicKeys: publicKeys,
signMethod: jwt.SigningMethodES256,
keycache: cache.NewCacheWithExpiration("PKIVerifierKey", validity),
validity: validity,
}
} | [
"func",
"NewPKIVerifier",
"(",
"publicKeys",
"[",
"]",
"*",
"ecdsa",
".",
"PublicKey",
",",
"cacheValidity",
"time",
".",
"Duration",
")",
"PKITokenVerifier",
"{",
"validity",
":=",
"defaultValidity",
"*",
"time",
".",
"Second",
"\n",
"if",
"cacheValidity",
">... | // NewPKIVerifier returns a new PKIConfiguration. | [
"NewPKIVerifier",
"returns",
"a",
"new",
"PKIConfiguration",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pkiverifier/pkiverifier.go#L61-L74 |
6,815 | aporeto-inc/trireme-lib | controller/pkg/pkiverifier/pkiverifier.go | Verify | func (p *tokenManager) Verify(token []byte) (*DatapathKey, error) {
tokenString := string(token)
if pk, err := p.keycache.Get(tokenString); err == nil {
return pk.(*DatapathKey), err
}
claims := &verifierClaims{}
var JWTToken *jwt.Token
var err error
for _, pk := range p.publicKeys {
if pk == nil {
continue
}
JWTToken, err = jwt.ParseWithClaims(tokenString, claims, func(_ *jwt.Token) (interface{}, error) { // nolint
return pk, nil
})
if err != nil || !JWTToken.Valid {
continue
}
dp := &DatapathKey{
PublicKey: KeyFromClaims(claims),
Tags: claims.Tags,
}
if time.Now().Add(p.validity).Unix() <= claims.ExpiresAt {
p.keycache.AddOrUpdate(tokenString, dp)
}
return dp, nil
}
return nil, errors.New("unable to verify token against any available public key")
} | go | func (p *tokenManager) Verify(token []byte) (*DatapathKey, error) {
tokenString := string(token)
if pk, err := p.keycache.Get(tokenString); err == nil {
return pk.(*DatapathKey), err
}
claims := &verifierClaims{}
var JWTToken *jwt.Token
var err error
for _, pk := range p.publicKeys {
if pk == nil {
continue
}
JWTToken, err = jwt.ParseWithClaims(tokenString, claims, func(_ *jwt.Token) (interface{}, error) { // nolint
return pk, nil
})
if err != nil || !JWTToken.Valid {
continue
}
dp := &DatapathKey{
PublicKey: KeyFromClaims(claims),
Tags: claims.Tags,
}
if time.Now().Add(p.validity).Unix() <= claims.ExpiresAt {
p.keycache.AddOrUpdate(tokenString, dp)
}
return dp, nil
}
return nil, errors.New("unable to verify token against any available public key")
} | [
"func",
"(",
"p",
"*",
"tokenManager",
")",
"Verify",
"(",
"token",
"[",
"]",
"byte",
")",
"(",
"*",
"DatapathKey",
",",
"error",
")",
"{",
"tokenString",
":=",
"string",
"(",
"token",
")",
"\n",
"if",
"pk",
",",
"err",
":=",
"p",
".",
"keycache",
... | // Verify verifies a token and returns the public key | [
"Verify",
"verifies",
"a",
"token",
"and",
"returns",
"the",
"public",
"key"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pkiverifier/pkiverifier.go#L77-L112 |
6,816 | aporeto-inc/trireme-lib | controller/pkg/pkiverifier/pkiverifier.go | CreateTokenFromCertificate | func (p *tokenManager) CreateTokenFromCertificate(cert *x509.Certificate, tags []string) ([]byte, error) {
// Combine the application claims with the standard claims
claims := &verifierClaims{
X: cert.PublicKey.(*ecdsa.PublicKey).X,
Y: cert.PublicKey.(*ecdsa.PublicKey).Y,
Tags: tags,
}
claims.ExpiresAt = cert.NotAfter.Unix()
// Create the token and sign with our key
strtoken, err := jwt.NewWithClaims(p.signMethod, claims).SignedString(p.privateKey)
if err != nil {
return []byte{}, err
}
return []byte(strtoken), nil
} | go | func (p *tokenManager) CreateTokenFromCertificate(cert *x509.Certificate, tags []string) ([]byte, error) {
// Combine the application claims with the standard claims
claims := &verifierClaims{
X: cert.PublicKey.(*ecdsa.PublicKey).X,
Y: cert.PublicKey.(*ecdsa.PublicKey).Y,
Tags: tags,
}
claims.ExpiresAt = cert.NotAfter.Unix()
// Create the token and sign with our key
strtoken, err := jwt.NewWithClaims(p.signMethod, claims).SignedString(p.privateKey)
if err != nil {
return []byte{}, err
}
return []byte(strtoken), nil
} | [
"func",
"(",
"p",
"*",
"tokenManager",
")",
"CreateTokenFromCertificate",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
",",
"tags",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Combine the application claims with the standard clai... | // CreateTokenFromCertificate creates and signs a token | [
"CreateTokenFromCertificate",
"creates",
"and",
"signs",
"a",
"token"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pkiverifier/pkiverifier.go#L115-L132 |
6,817 | aporeto-inc/trireme-lib | controller/pkg/pkiverifier/pkiverifier.go | KeyFromClaims | func KeyFromClaims(claims *verifierClaims) *ecdsa.PublicKey {
return &ecdsa.PublicKey{
Curve: elliptic.P256(),
X: claims.X,
Y: claims.Y,
}
} | go | func KeyFromClaims(claims *verifierClaims) *ecdsa.PublicKey {
return &ecdsa.PublicKey{
Curve: elliptic.P256(),
X: claims.X,
Y: claims.Y,
}
} | [
"func",
"KeyFromClaims",
"(",
"claims",
"*",
"verifierClaims",
")",
"*",
"ecdsa",
".",
"PublicKey",
"{",
"return",
"&",
"ecdsa",
".",
"PublicKey",
"{",
"Curve",
":",
"elliptic",
".",
"P256",
"(",
")",
",",
"X",
":",
"claims",
".",
"X",
",",
"Y",
":",... | // KeyFromClaims creates the public key structure from the claims | [
"KeyFromClaims",
"creates",
"the",
"public",
"key",
"structure",
"from",
"the",
"claims"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pkiverifier/pkiverifier.go#L135-L141 |
6,818 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/tcp/tcp.go | NewTCPProxy | func NewTCPProxy(
tp tokenaccessor.TokenAccessor,
c collector.EventCollector,
puContext string,
registry *serviceregistry.Registry,
certificate *tls.Certificate,
caPool *x509.CertPool,
) *Proxy {
localIPs := markedconn.GetInterfaces()
return &Proxy{
collector: c,
tokenaccessor: tp,
puContext: puContext,
registry: registry,
localIPs: localIPs,
certificate: certificate,
ca: caPool,
}
} | go | func NewTCPProxy(
tp tokenaccessor.TokenAccessor,
c collector.EventCollector,
puContext string,
registry *serviceregistry.Registry,
certificate *tls.Certificate,
caPool *x509.CertPool,
) *Proxy {
localIPs := markedconn.GetInterfaces()
return &Proxy{
collector: c,
tokenaccessor: tp,
puContext: puContext,
registry: registry,
localIPs: localIPs,
certificate: certificate,
ca: caPool,
}
} | [
"func",
"NewTCPProxy",
"(",
"tp",
"tokenaccessor",
".",
"TokenAccessor",
",",
"c",
"collector",
".",
"EventCollector",
",",
"puContext",
"string",
",",
"registry",
"*",
"serviceregistry",
".",
"Registry",
",",
"certificate",
"*",
"tls",
".",
"Certificate",
",",
... | // NewTCPProxy creates a new instance of proxy reate a new instance of Proxy | [
"NewTCPProxy",
"creates",
"a",
"new",
"instance",
"of",
"proxy",
"reate",
"a",
"new",
"instance",
"of",
"Proxy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/tcp/tcp.go#L66-L86 |
6,819 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/tcp/tcp.go | RunNetworkServer | func (p *Proxy) RunNetworkServer(ctx context.Context, listener net.Listener, encrypted bool) error {
// Encryption is done transparently for TCP.
go p.serve(ctx, listener)
return nil
} | go | func (p *Proxy) RunNetworkServer(ctx context.Context, listener net.Listener, encrypted bool) error {
// Encryption is done transparently for TCP.
go p.serve(ctx, listener)
return nil
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"RunNetworkServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"listener",
"net",
".",
"Listener",
",",
"encrypted",
"bool",
")",
"error",
"{",
"// Encryption is done transparently for TCP.",
"go",
"p",
".",
"serve",
"(",
... | // RunNetworkServer implements enforcer.Enforcer interface | [
"RunNetworkServer",
"implements",
"enforcer",
".",
"Enforcer",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/tcp/tcp.go#L89-L95 |
6,820 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/tcp/tcp.go | UpdateSecrets | func (p *Proxy) UpdateSecrets(cert *tls.Certificate, caPool *x509.CertPool, s secrets.Secrets, certPEM, keyPEM string) {
p.Lock()
defer p.Unlock()
p.certificate = cert
p.ca = caPool
} | go | func (p *Proxy) UpdateSecrets(cert *tls.Certificate, caPool *x509.CertPool, s secrets.Secrets, certPEM, keyPEM string) {
p.Lock()
defer p.Unlock()
p.certificate = cert
p.ca = caPool
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"UpdateSecrets",
"(",
"cert",
"*",
"tls",
".",
"Certificate",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
"s",
"secrets",
".",
"Secrets",
",",
"certPEM",
",",
"keyPEM",
"string",
")",
"{",
"p",
".",
"Lock",
... | // UpdateSecrets updates the secrets of the connections. | [
"UpdateSecrets",
"updates",
"the",
"secrets",
"of",
"the",
"connections",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/tcp/tcp.go#L98-L104 |
6,821 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/tcp/tcp.go | handle | func (p *Proxy) handle(ctx context.Context, upConn net.Conn) {
defer upConn.Close() // nolint
ip, port := upConn.(*markedconn.ProxiedConnection).GetOriginalDestination()
downConn, err := p.downConnection(ctx, ip, port)
if err != nil {
flowproperties := &proxyFlowProperties{
DestIP: ip.String(),
DestPort: uint16(port),
SourceIP: upConn.RemoteAddr().(*net.TCPAddr).IP.String(),
DestType: collector.EndPointTypeExternalIP,
SourceType: collector.EnpointTypePU,
}
puContext, perr := p.puContextFromContextID(p.puContext)
if perr != nil {
zap.L().Error("Unable to find policy context for tcp connection",
zap.String("Context", p.puContext),
zap.Error(perr))
return
}
p.reportRejectedFlow(flowproperties, puContext.ManagementID(), "default", puContext, collector.UnableToDial, nil, nil)
return
}
defer downConn.Close() // nolint
// Now let us handle the state machine for the down connection
isEncrypted, err := p.CompleteEndPointAuthorization(ip, port, upConn, downConn)
if err != nil {
zap.L().Error("Error on Authorization", zap.Error(err))
return
}
if err := p.proxyData(ctx, isEncrypted, upConn, downConn); err != nil {
zap.L().Debug("Error will proxying data", zap.Error(err))
}
} | go | func (p *Proxy) handle(ctx context.Context, upConn net.Conn) {
defer upConn.Close() // nolint
ip, port := upConn.(*markedconn.ProxiedConnection).GetOriginalDestination()
downConn, err := p.downConnection(ctx, ip, port)
if err != nil {
flowproperties := &proxyFlowProperties{
DestIP: ip.String(),
DestPort: uint16(port),
SourceIP: upConn.RemoteAddr().(*net.TCPAddr).IP.String(),
DestType: collector.EndPointTypeExternalIP,
SourceType: collector.EnpointTypePU,
}
puContext, perr := p.puContextFromContextID(p.puContext)
if perr != nil {
zap.L().Error("Unable to find policy context for tcp connection",
zap.String("Context", p.puContext),
zap.Error(perr))
return
}
p.reportRejectedFlow(flowproperties, puContext.ManagementID(), "default", puContext, collector.UnableToDial, nil, nil)
return
}
defer downConn.Close() // nolint
// Now let us handle the state machine for the down connection
isEncrypted, err := p.CompleteEndPointAuthorization(ip, port, upConn, downConn)
if err != nil {
zap.L().Error("Error on Authorization", zap.Error(err))
return
}
if err := p.proxyData(ctx, isEncrypted, upConn, downConn); err != nil {
zap.L().Debug("Error will proxying data", zap.Error(err))
}
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"handle",
"(",
"ctx",
"context",
".",
"Context",
",",
"upConn",
"net",
".",
"Conn",
")",
"{",
"defer",
"upConn",
".",
"Close",
"(",
")",
"// nolint",
"\n",
"ip",
",",
"port",
":=",
"upConn",
".",
"(",
"*",
"ma... | // handle handles a connection | [
"handle",
"handles",
"a",
"connection"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/tcp/tcp.go#L127-L164 |
6,822 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/tcp/tcp.go | downConnection | func (p *Proxy) downConnection(ctx context.Context, ip net.IP, port int) (net.Conn, error) {
raddr := &net.TCPAddr{
IP: ip,
Port: port,
}
return markedconn.DialMarkedWithContext(ctx, "tcp4", raddr.String(), proxyMarkInt)
} | go | func (p *Proxy) downConnection(ctx context.Context, ip net.IP, port int) (net.Conn, error) {
raddr := &net.TCPAddr{
IP: ip,
Port: port,
}
return markedconn.DialMarkedWithContext(ctx, "tcp4", raddr.String(), proxyMarkInt)
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"downConnection",
"(",
"ctx",
"context",
".",
"Context",
",",
"ip",
"net",
".",
"IP",
",",
"port",
"int",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"raddr",
":=",
"&",
"net",
".",
"TCPAddr",
"{",
... | // Initiate the downstream connection | [
"Initiate",
"the",
"downstream",
"connection"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/tcp/tcp.go#L274-L283 |
6,823 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/handler.go | RefreshPUs | func (m *KubernetesMonitor) RefreshPUs(ctx context.Context, pod *api.Pod) error {
if pod == nil {
return fmt.Errorf("pod is nil")
}
podNamespace := pod.GetNamespace()
podName := pod.GetName()
puIDs := m.cache.getPUIDsbyPod(podNamespace, podName)
for _, puid := range puIDs {
dockerRuntime := m.cache.getDockerRuntimeByPUID(puid)
if dockerRuntime == nil {
continue
}
kubernetesRuntime, managedContainer, err := m.kubernetesExtractor(dockerRuntime, pod)
if err != nil {
return fmt.Errorf("error while processing Kubernetes pod %s/%s for container %s %s", podNamespace, podName, puid, err)
}
// UnmanagedContainers are simply ignored. It should not come this far if it is a non managed container anyways.
if !managedContainer {
zap.L().Debug("unmanaged Kubernetes container", zap.String("puID", puid), zap.String("podNamespace", podNamespace), zap.String("podName", podName))
continue
}
// We keep the cache uptoDate for future queries
m.cache.updatePUIDCache(podNamespace, podName, puid, dockerRuntime, kubernetesRuntime)
if err := m.handlers.Policy.HandlePUEvent(ctx, puid, common.EventUpdate, kubernetesRuntime); err != nil {
return err
}
}
return nil
} | go | func (m *KubernetesMonitor) RefreshPUs(ctx context.Context, pod *api.Pod) error {
if pod == nil {
return fmt.Errorf("pod is nil")
}
podNamespace := pod.GetNamespace()
podName := pod.GetName()
puIDs := m.cache.getPUIDsbyPod(podNamespace, podName)
for _, puid := range puIDs {
dockerRuntime := m.cache.getDockerRuntimeByPUID(puid)
if dockerRuntime == nil {
continue
}
kubernetesRuntime, managedContainer, err := m.kubernetesExtractor(dockerRuntime, pod)
if err != nil {
return fmt.Errorf("error while processing Kubernetes pod %s/%s for container %s %s", podNamespace, podName, puid, err)
}
// UnmanagedContainers are simply ignored. It should not come this far if it is a non managed container anyways.
if !managedContainer {
zap.L().Debug("unmanaged Kubernetes container", zap.String("puID", puid), zap.String("podNamespace", podNamespace), zap.String("podName", podName))
continue
}
// We keep the cache uptoDate for future queries
m.cache.updatePUIDCache(podNamespace, podName, puid, dockerRuntime, kubernetesRuntime)
if err := m.handlers.Policy.HandlePUEvent(ctx, puid, common.EventUpdate, kubernetesRuntime); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"KubernetesMonitor",
")",
"RefreshPUs",
"(",
"ctx",
"context",
".",
"Context",
",",
"pod",
"*",
"api",
".",
"Pod",
")",
"error",
"{",
"if",
"pod",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
... | // RefreshPUs is used to resend an update event to the Upstream Policy Resolver in case of an update is needed. | [
"RefreshPUs",
"is",
"used",
"to",
"resend",
"an",
"update",
"event",
"to",
"the",
"Upstream",
"Policy",
"Resolver",
"in",
"case",
"of",
"an",
"update",
"is",
"needed",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/handler.go#L91-L127 |
6,824 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/handler.go | getKubernetesInformation | func getKubernetesInformation(runtime policy.RuntimeReader) (string, string, error) {
podNamespace, ok := runtime.Tag(KubernetesPodNamespaceIdentifier)
if !ok {
return "", "", fmt.Errorf("Error getting Kubernetes Pod namespace")
}
podName, ok := runtime.Tag(KubernetesPodNameIdentifier)
if !ok {
return "", "", fmt.Errorf("Error getting Kubernetes Pod name")
}
return podNamespace, podName, nil
} | go | func getKubernetesInformation(runtime policy.RuntimeReader) (string, string, error) {
podNamespace, ok := runtime.Tag(KubernetesPodNamespaceIdentifier)
if !ok {
return "", "", fmt.Errorf("Error getting Kubernetes Pod namespace")
}
podName, ok := runtime.Tag(KubernetesPodNameIdentifier)
if !ok {
return "", "", fmt.Errorf("Error getting Kubernetes Pod name")
}
return podNamespace, podName, nil
} | [
"func",
"getKubernetesInformation",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"podNamespace",
",",
"ok",
":=",
"runtime",
".",
"Tag",
"(",
"KubernetesPodNamespaceIdentifier",
")",
"\n",
"if",
"!"... | // getKubernetesInformation returns the name and namespace from a standard Docker runtime, if the docker container is associated at all with Kubernetes | [
"getKubernetesInformation",
"returns",
"the",
"name",
"and",
"namespace",
"from",
"a",
"standard",
"Docker",
"runtime",
"if",
"the",
"docker",
"container",
"is",
"associated",
"at",
"all",
"with",
"Kubernetes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/handler.go#L130-L141 |
6,825 | aporeto-inc/trireme-lib | monitor/internal/kubernetes/handler.go | decorateRuntime | func (m *KubernetesMonitor) decorateRuntime(puID string, runtimeInfo policy.RuntimeReader, event common.Event,
podName, podNamespace string) (err error) {
// Do nothing on other events apart from start event.
if event != common.EventStart {
return nil
}
puRuntime, ok := runtimeInfo.(*policy.PURuntime)
if !ok {
zap.L().Error("Found invalid runtime for puid", zap.String("puid", puID))
return fmt.Errorf("invalid runtime for puid:%s", puID)
}
extensions := policy.ExtendedMap{}
// pause container with host net set to true.
if runtimeInfo.PUType() == common.LinuxProcessPU {
extensions[constants.DockerHostMode] = "true"
extensions[constants.DockerHostPUID] = puID
options := puRuntime.Options()
options.PolicyExtensions = extensions
// set Options on docker runtime.
puRuntime.SetOptions(options)
return nil
}
pausePUID := ""
puIDs := m.cache.getPUIDsbyPod(podNamespace, podName)
// get the puid of the pause container.
for _, id := range puIDs {
rtm := m.cache.getDockerRuntimeByPUID(id)
if rtm == nil {
continue
}
if isPodInfraContainer(rtm) && rtm.PUType() == common.LinuxProcessPU {
pausePUID = id
break
}
// if the pause container is not host net container, nothing to do.
if isPodInfraContainer(rtm) {
return nil
}
}
extensions[constants.DockerHostPUID] = pausePUID
options := puRuntime.Options()
options.PolicyExtensions = extensions
// set Options on docker runtime.
puRuntime.SetOptions(options)
return nil
} | go | func (m *KubernetesMonitor) decorateRuntime(puID string, runtimeInfo policy.RuntimeReader, event common.Event,
podName, podNamespace string) (err error) {
// Do nothing on other events apart from start event.
if event != common.EventStart {
return nil
}
puRuntime, ok := runtimeInfo.(*policy.PURuntime)
if !ok {
zap.L().Error("Found invalid runtime for puid", zap.String("puid", puID))
return fmt.Errorf("invalid runtime for puid:%s", puID)
}
extensions := policy.ExtendedMap{}
// pause container with host net set to true.
if runtimeInfo.PUType() == common.LinuxProcessPU {
extensions[constants.DockerHostMode] = "true"
extensions[constants.DockerHostPUID] = puID
options := puRuntime.Options()
options.PolicyExtensions = extensions
// set Options on docker runtime.
puRuntime.SetOptions(options)
return nil
}
pausePUID := ""
puIDs := m.cache.getPUIDsbyPod(podNamespace, podName)
// get the puid of the pause container.
for _, id := range puIDs {
rtm := m.cache.getDockerRuntimeByPUID(id)
if rtm == nil {
continue
}
if isPodInfraContainer(rtm) && rtm.PUType() == common.LinuxProcessPU {
pausePUID = id
break
}
// if the pause container is not host net container, nothing to do.
if isPodInfraContainer(rtm) {
return nil
}
}
extensions[constants.DockerHostPUID] = pausePUID
options := puRuntime.Options()
options.PolicyExtensions = extensions
// set Options on docker runtime.
puRuntime.SetOptions(options)
return nil
} | [
"func",
"(",
"m",
"*",
"KubernetesMonitor",
")",
"decorateRuntime",
"(",
"puID",
"string",
",",
"runtimeInfo",
"policy",
".",
"RuntimeReader",
",",
"event",
"common",
".",
"Event",
",",
"podName",
",",
"podNamespace",
"string",
")",
"(",
"err",
"error",
")",... | // decorateRuntime decorates the docker runtime with puid of the pause container. | [
"decorateRuntime",
"decorates",
"the",
"docker",
"runtime",
"with",
"puid",
"of",
"the",
"pause",
"container",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/kubernetes/handler.go#L144-L199 |
6,826 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/mockstatsclient/mockstatsclient.go | NewMockStatsClient | func NewMockStatsClient(ctrl *gomock.Controller) *MockStatsClient {
mock := &MockStatsClient{ctrl: ctrl}
mock.recorder = &MockStatsClientMockRecorder{mock}
return mock
} | go | func NewMockStatsClient(ctrl *gomock.Controller) *MockStatsClient {
mock := &MockStatsClient{ctrl: ctrl}
mock.recorder = &MockStatsClientMockRecorder{mock}
return mock
} | [
"func",
"NewMockStatsClient",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockStatsClient",
"{",
"mock",
":=",
"&",
"MockStatsClient",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockStatsClientMockRecorder",
"{",
"... | // NewMockStatsClient creates a new mock instance
// nolint | [
"NewMockStatsClient",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/mockstatsclient/mockstatsclient.go#L29-L33 |
6,827 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/mockstatsclient/mockstatsclient.go | SendStats | func (mr *MockStatsClientMockRecorder) SendStats() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendStats", reflect.TypeOf((*MockStatsClient)(nil).SendStats))
} | go | func (mr *MockStatsClientMockRecorder) SendStats() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendStats", reflect.TypeOf((*MockStatsClient)(nil).SendStats))
} | [
"func",
"(",
"mr",
"*",
"MockStatsClientMockRecorder",
")",
"SendStats",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
... | // SendStats indicates an expected call of SendStats
// nolint | [
"SendStats",
"indicates",
"an",
"expected",
"call",
"of",
"SendStats",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/mockstatsclient/mockstatsclient.go#L63-L65 |
6,828 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | processNetUDPPacket | func (d *Datapath) processNetUDPPacket(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (action interface{}, claims *tokens.ConnectionClaims, err error) {
// Extra check, just in case the caller didn't provide a connection.
if conn == nil {
return nil, nil, fmt.Errorf("no connection provided")
}
udpPacketType := udpPacket.GetUDPType()
// Update connection state in the internal state machine tracker
switch udpPacketType {
case packet.UDPSynMask:
// Parse the packet for the identity information.
action, claims, err = d.processNetworkUDPSynPacket(context, conn, udpPacket)
if err != nil {
return nil, nil, err
}
// Send the return packet.
if err = d.sendUDPSynAckPacket(udpPacket, context, conn); err != nil {
return nil, nil, err
}
// Mark the state that we have transmitted a SynAck packet.
conn.SetState(connection.UDPReceiverSendSynAck)
return action, claims, nil
case packet.UDPAckMask:
// Retrieve the header and parse the signatures.
if err = d.processNetworkUDPAckPacket(udpPacket, context, conn); err != nil {
zap.L().Error("Error during authorization", zap.Error(err))
return nil, nil, err
}
// Set the connection to
conn.SetState(connection.UDPReceiverProcessedAck)
return nil, nil, nil
case packet.UDPSynAckMask:
// Process the synack header and claims of the other side.
action, claims, err = d.processNetworkUDPSynAckPacket(udpPacket, context, conn)
if err != nil {
zap.L().Error("UDP Syn ack failed with", zap.Error(err))
return nil, nil, err
}
// Send back the acknowledgement.
err = d.sendUDPAckPacket(udpPacket, context, conn)
if err != nil {
zap.L().Error("Unable to send udp Syn ack failed", zap.Error(err))
return nil, nil, err
}
conn.SetState(connection.UDPClientSendAck)
return action, claims, nil
default:
state := conn.GetState()
if state == connection.UDPReceiverProcessedAck || state == connection.UDPClientSendAck || state == connection.UDPData {
conn.SetState(connection.UDPData)
return nil, nil, nil
}
return nil, nil, fmt.Errorf("invalid packet at state: %d", state)
}
} | go | func (d *Datapath) processNetUDPPacket(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (action interface{}, claims *tokens.ConnectionClaims, err error) {
// Extra check, just in case the caller didn't provide a connection.
if conn == nil {
return nil, nil, fmt.Errorf("no connection provided")
}
udpPacketType := udpPacket.GetUDPType()
// Update connection state in the internal state machine tracker
switch udpPacketType {
case packet.UDPSynMask:
// Parse the packet for the identity information.
action, claims, err = d.processNetworkUDPSynPacket(context, conn, udpPacket)
if err != nil {
return nil, nil, err
}
// Send the return packet.
if err = d.sendUDPSynAckPacket(udpPacket, context, conn); err != nil {
return nil, nil, err
}
// Mark the state that we have transmitted a SynAck packet.
conn.SetState(connection.UDPReceiverSendSynAck)
return action, claims, nil
case packet.UDPAckMask:
// Retrieve the header and parse the signatures.
if err = d.processNetworkUDPAckPacket(udpPacket, context, conn); err != nil {
zap.L().Error("Error during authorization", zap.Error(err))
return nil, nil, err
}
// Set the connection to
conn.SetState(connection.UDPReceiverProcessedAck)
return nil, nil, nil
case packet.UDPSynAckMask:
// Process the synack header and claims of the other side.
action, claims, err = d.processNetworkUDPSynAckPacket(udpPacket, context, conn)
if err != nil {
zap.L().Error("UDP Syn ack failed with", zap.Error(err))
return nil, nil, err
}
// Send back the acknowledgement.
err = d.sendUDPAckPacket(udpPacket, context, conn)
if err != nil {
zap.L().Error("Unable to send udp Syn ack failed", zap.Error(err))
return nil, nil, err
}
conn.SetState(connection.UDPClientSendAck)
return action, claims, nil
default:
state := conn.GetState()
if state == connection.UDPReceiverProcessedAck || state == connection.UDPClientSendAck || state == connection.UDPData {
conn.SetState(connection.UDPData)
return nil, nil, nil
}
return nil, nil, fmt.Errorf("invalid packet at state: %d", state)
}
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processNetUDPPacket",
"(",
"udpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"UDPConnection",
")",
"(",
"action",
"interface",
"{",
"... | // processNetUDPPacket processes a network UDP packet and dispatches it to different methods based on the flags.
// This applies only to control packets. | [
"processNetUDPPacket",
"processes",
"a",
"network",
"UDP",
"packet",
"and",
"dispatches",
"it",
"to",
"different",
"methods",
"based",
"on",
"the",
"flags",
".",
"This",
"applies",
"only",
"to",
"control",
"packets",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L199-L266 |
6,829 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | ProcessApplicationUDPPacket | func (d *Datapath) ProcessApplicationUDPPacket(p *packet.Packet) (conn *connection.UDPConnection, err error) {
if d.packetLogs {
zap.L().Debug("Processing application UDP packet ",
zap.String("flow", p.L4FlowHash()),
)
defer zap.L().Debug("Finished Processing UDP application packet ",
zap.String("flow", p.L4FlowHash()),
zap.Error(err),
)
}
// First retrieve the connection state.
conn, err = d.appUDPRetrieveState(p)
if err != nil {
zap.L().Debug("Connection not found", zap.Error(err))
return nil, fmt.Errorf("Received packet from unenforced process: %s", err)
}
// We are processing only one packet from a given connection at a time.
conn.Lock()
defer conn.Unlock()
// do some pre processing.
if d.service != nil {
// PreProcessServiceInterface
if !d.service.PreProcessUDPAppPacket(p, conn.Context, conn, packet.UDPSynMask) {
p.Print(packet.PacketFailureService)
return nil, fmt.Errorf("pre service processing failed for UDP application packet")
}
}
triggerControlProtocol := false
switch conn.GetState() {
case connection.UDPStart:
// Queue the packet. We will send it after we authorize the session.
if err = conn.QueuePackets(p); err != nil {
// unable to queue packets, perhaps queue is full. if start
// machine is still in start state, we can start authorisation
// again. A drop counter is incremented.
zap.L().Debug("udp queue full for connection", zap.String("flow", p.L4FlowHash()))
}
// Set the state indicating that we send out a Syn packet
conn.SetState(connection.UDPClientSendSyn)
// Drop the packet. We stored it in the queue.
triggerControlProtocol = true
case connection.UDPReceiverProcessedAck, connection.UDPClientSendAck, connection.UDPData:
conn.SetState(connection.UDPData)
default:
zap.L().Debug("Packet is added to the queue", zap.String("flow", p.L4FlowHash()))
if err = conn.QueuePackets(p); err != nil {
return conn, fmt.Errorf("Unable to queue packets:%s", err)
}
return conn, fmt.Errorf("Drop in nfq - buffered")
}
if d.service != nil {
// PostProcessServiceInterface
if !d.service.PostProcessUDPAppPacket(p, nil, conn.Context, conn) {
p.Print(packet.PacketFailureService)
return conn, fmt.Errorf("Encryption failed for application packet")
}
}
if triggerControlProtocol {
err = d.triggerNegotiation(p, conn.Context, conn)
if err != nil {
return conn, err
}
return conn, fmt.Errorf("Drop in nfq - buffered")
}
return conn, nil
} | go | func (d *Datapath) ProcessApplicationUDPPacket(p *packet.Packet) (conn *connection.UDPConnection, err error) {
if d.packetLogs {
zap.L().Debug("Processing application UDP packet ",
zap.String("flow", p.L4FlowHash()),
)
defer zap.L().Debug("Finished Processing UDP application packet ",
zap.String("flow", p.L4FlowHash()),
zap.Error(err),
)
}
// First retrieve the connection state.
conn, err = d.appUDPRetrieveState(p)
if err != nil {
zap.L().Debug("Connection not found", zap.Error(err))
return nil, fmt.Errorf("Received packet from unenforced process: %s", err)
}
// We are processing only one packet from a given connection at a time.
conn.Lock()
defer conn.Unlock()
// do some pre processing.
if d.service != nil {
// PreProcessServiceInterface
if !d.service.PreProcessUDPAppPacket(p, conn.Context, conn, packet.UDPSynMask) {
p.Print(packet.PacketFailureService)
return nil, fmt.Errorf("pre service processing failed for UDP application packet")
}
}
triggerControlProtocol := false
switch conn.GetState() {
case connection.UDPStart:
// Queue the packet. We will send it after we authorize the session.
if err = conn.QueuePackets(p); err != nil {
// unable to queue packets, perhaps queue is full. if start
// machine is still in start state, we can start authorisation
// again. A drop counter is incremented.
zap.L().Debug("udp queue full for connection", zap.String("flow", p.L4FlowHash()))
}
// Set the state indicating that we send out a Syn packet
conn.SetState(connection.UDPClientSendSyn)
// Drop the packet. We stored it in the queue.
triggerControlProtocol = true
case connection.UDPReceiverProcessedAck, connection.UDPClientSendAck, connection.UDPData:
conn.SetState(connection.UDPData)
default:
zap.L().Debug("Packet is added to the queue", zap.String("flow", p.L4FlowHash()))
if err = conn.QueuePackets(p); err != nil {
return conn, fmt.Errorf("Unable to queue packets:%s", err)
}
return conn, fmt.Errorf("Drop in nfq - buffered")
}
if d.service != nil {
// PostProcessServiceInterface
if !d.service.PostProcessUDPAppPacket(p, nil, conn.Context, conn) {
p.Print(packet.PacketFailureService)
return conn, fmt.Errorf("Encryption failed for application packet")
}
}
if triggerControlProtocol {
err = d.triggerNegotiation(p, conn.Context, conn)
if err != nil {
return conn, err
}
return conn, fmt.Errorf("Drop in nfq - buffered")
}
return conn, nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"ProcessApplicationUDPPacket",
"(",
"p",
"*",
"packet",
".",
"Packet",
")",
"(",
"conn",
"*",
"connection",
".",
"UDPConnection",
",",
"err",
"error",
")",
"{",
"if",
"d",
".",
"packetLogs",
"{",
"zap",
".",
"L",... | // ProcessApplicationUDPPacket processes packets arriving from an application and are destined to the network | [
"ProcessApplicationUDPPacket",
"processes",
"packets",
"arriving",
"from",
"an",
"application",
"and",
"are",
"destined",
"to",
"the",
"network"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L269-L344 |
6,830 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | triggerNegotiation | func (d *Datapath) triggerNegotiation(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (err error) {
udpOptions := packet.CreateUDPAuthMarker(packet.UDPSynMask)
udpData, err := d.tokenAccessor.CreateSynPacketToken(context, &conn.Auth)
if err != nil {
return err
}
newPacket, err := d.clonePacketHeaders(udpPacket)
if err != nil {
return fmt.Errorf("Unable to clone packet: %s", err)
}
// Attach the UDP data and token
newPacket.UDPTokenAttach(udpOptions, udpData)
// send packet
err = d.writeWithRetransmit(newPacket.GetBuffer(0), conn, conn.SynChannel())
if err != nil {
zap.L().Error("Unable to send syn token on raw socket", zap.Error(err))
return fmt.Errorf("unable to transmit syn packet")
}
// Populate the caches to track the connection
hash := udpPacket.L4FlowHash()
d.udpAppOrigConnectionTracker.AddOrUpdate(hash, conn)
d.udpSourcePortConnectionCache.AddOrUpdate(newPacket.SourcePortHash(packet.PacketTypeApplication), conn)
d.udpNatConnectionTracker.AddOrUpdate(newPacket.SourcePortHash(packet.PacketTypeApplication), newPacket.SourcePortHash(packet.PacketTypeNetwork))
return nil
} | go | func (d *Datapath) triggerNegotiation(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (err error) {
udpOptions := packet.CreateUDPAuthMarker(packet.UDPSynMask)
udpData, err := d.tokenAccessor.CreateSynPacketToken(context, &conn.Auth)
if err != nil {
return err
}
newPacket, err := d.clonePacketHeaders(udpPacket)
if err != nil {
return fmt.Errorf("Unable to clone packet: %s", err)
}
// Attach the UDP data and token
newPacket.UDPTokenAttach(udpOptions, udpData)
// send packet
err = d.writeWithRetransmit(newPacket.GetBuffer(0), conn, conn.SynChannel())
if err != nil {
zap.L().Error("Unable to send syn token on raw socket", zap.Error(err))
return fmt.Errorf("unable to transmit syn packet")
}
// Populate the caches to track the connection
hash := udpPacket.L4FlowHash()
d.udpAppOrigConnectionTracker.AddOrUpdate(hash, conn)
d.udpSourcePortConnectionCache.AddOrUpdate(newPacket.SourcePortHash(packet.PacketTypeApplication), conn)
d.udpNatConnectionTracker.AddOrUpdate(newPacket.SourcePortHash(packet.PacketTypeApplication), newPacket.SourcePortHash(packet.PacketTypeNetwork))
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"triggerNegotiation",
"(",
"udpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"UDPConnection",
")",
"(",
"err",
"error",
")",
"{",
"u... | // processApplicationUDPSynPacket processes a single Syn Packet | [
"processApplicationUDPSynPacket",
"processes",
"a",
"single",
"Syn",
"Packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L367-L398 |
6,831 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | sendUDPSynAckPacket | func (d *Datapath) sendUDPSynAckPacket(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (err error) {
// Create UDP Option
udpOptions := packet.CreateUDPAuthMarker(packet.UDPSynAckMask)
udpData, err := d.tokenAccessor.CreateSynAckPacketToken(context, &conn.Auth, claimsheader.NewClaimsHeader())
if err != nil {
return err
}
udpPacket.CreateReverseFlowPacket(udpPacket.SourceAddress(), udpPacket.SourcePort())
// Attach the UDP data and token
udpPacket.UDPTokenAttach(udpOptions, udpData)
// If we have already a backgroun re-transmit session, stop it at this point. We will
// start from the beginning.
if conn.GetState() == connection.UDPReceiverSendSynAck {
conn.SynAckStop()
}
// Only start the retransmission timer once. Not on every packet.
if err := d.writeWithRetransmit(udpPacket.GetBuffer(0), conn, conn.SynAckChannel()); err != nil {
zap.L().Debug("Unable to send synack token on raw socket", zap.Error(err))
return err
}
return nil
} | go | func (d *Datapath) sendUDPSynAckPacket(udpPacket *packet.Packet, context *pucontext.PUContext, conn *connection.UDPConnection) (err error) {
// Create UDP Option
udpOptions := packet.CreateUDPAuthMarker(packet.UDPSynAckMask)
udpData, err := d.tokenAccessor.CreateSynAckPacketToken(context, &conn.Auth, claimsheader.NewClaimsHeader())
if err != nil {
return err
}
udpPacket.CreateReverseFlowPacket(udpPacket.SourceAddress(), udpPacket.SourcePort())
// Attach the UDP data and token
udpPacket.UDPTokenAttach(udpOptions, udpData)
// If we have already a backgroun re-transmit session, stop it at this point. We will
// start from the beginning.
if conn.GetState() == connection.UDPReceiverSendSynAck {
conn.SynAckStop()
}
// Only start the retransmission timer once. Not on every packet.
if err := d.writeWithRetransmit(udpPacket.GetBuffer(0), conn, conn.SynAckChannel()); err != nil {
zap.L().Debug("Unable to send synack token on raw socket", zap.Error(err))
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"sendUDPSynAckPacket",
"(",
"udpPacket",
"*",
"packet",
".",
"Packet",
",",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"UDPConnection",
")",
"(",
"err",
"error",
")",
"{",
"... | // sendUDPSynAckPacket processes a UDP SynAck packet | [
"sendUDPSynAckPacket",
"processes",
"a",
"UDP",
"SynAck",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L443-L471 |
6,832 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | processNetworkUDPSynPacket | func (d *Datapath) processNetworkUDPSynPacket(context *pucontext.PUContext, conn *connection.UDPConnection, udpPacket *packet.Packet) (action interface{}, claims *tokens.ConnectionClaims, err error) {
claims, err = d.tokenAccessor.ParsePacketToken(&conn.Auth, udpPacket.ReadUDPToken())
if err != nil {
d.reportUDPRejectedFlow(udpPacket, conn, collector.DefaultEndPoint, context.ManagementID(), context, tokens.CodeFromErr(err), nil, nil, false)
return nil, nil, fmt.Errorf("UDP Syn packet dropped because of invalid token: %s", err)
}
// if there are no claims we must drop the connection and we drop the Syn
// packet. The source will retry but we have no state to maintain here.
if claims == nil {
d.reportUDPRejectedFlow(udpPacket, conn, collector.DefaultEndPoint, context.ManagementID(), context, collector.InvalidToken, nil, nil, false)
return nil, nil, fmt.Errorf("UDP Syn packet dropped because of no claims")
}
// Why is this required. Take a look.
txLabel, _ := claims.T.Get(enforcerconstants.TransmitterLabel)
// Add the port as a label with an @ prefix. These labels are invalid otherwise
// If all policies are restricted by port numbers this will allow port-specific policies
claims.T.AppendKeyValue(enforcerconstants.PortNumberLabelString, strconv.Itoa(int(udpPacket.DestPort())))
report, pkt := context.SearchRcvRules(claims.T)
if pkt.Action.Rejected() {
d.reportUDPRejectedFlow(udpPacket, conn, txLabel, context.ManagementID(), context, collector.PolicyDrop, report, pkt, false)
return nil, nil, fmt.Errorf("connection rejected because of policy: %s", claims.T.String())
}
hash := udpPacket.L4FlowHash()
// conntrack
d.udpNetOrigConnectionTracker.AddOrUpdate(hash, conn)
d.udpAppReplyConnectionTracker.AddOrUpdate(udpPacket.L4ReverseFlowHash(), conn)
// Record actions
conn.ReportFlowPolicy = report
conn.PacketFlowPolicy = pkt
return pkt, claims, nil
} | go | func (d *Datapath) processNetworkUDPSynPacket(context *pucontext.PUContext, conn *connection.UDPConnection, udpPacket *packet.Packet) (action interface{}, claims *tokens.ConnectionClaims, err error) {
claims, err = d.tokenAccessor.ParsePacketToken(&conn.Auth, udpPacket.ReadUDPToken())
if err != nil {
d.reportUDPRejectedFlow(udpPacket, conn, collector.DefaultEndPoint, context.ManagementID(), context, tokens.CodeFromErr(err), nil, nil, false)
return nil, nil, fmt.Errorf("UDP Syn packet dropped because of invalid token: %s", err)
}
// if there are no claims we must drop the connection and we drop the Syn
// packet. The source will retry but we have no state to maintain here.
if claims == nil {
d.reportUDPRejectedFlow(udpPacket, conn, collector.DefaultEndPoint, context.ManagementID(), context, collector.InvalidToken, nil, nil, false)
return nil, nil, fmt.Errorf("UDP Syn packet dropped because of no claims")
}
// Why is this required. Take a look.
txLabel, _ := claims.T.Get(enforcerconstants.TransmitterLabel)
// Add the port as a label with an @ prefix. These labels are invalid otherwise
// If all policies are restricted by port numbers this will allow port-specific policies
claims.T.AppendKeyValue(enforcerconstants.PortNumberLabelString, strconv.Itoa(int(udpPacket.DestPort())))
report, pkt := context.SearchRcvRules(claims.T)
if pkt.Action.Rejected() {
d.reportUDPRejectedFlow(udpPacket, conn, txLabel, context.ManagementID(), context, collector.PolicyDrop, report, pkt, false)
return nil, nil, fmt.Errorf("connection rejected because of policy: %s", claims.T.String())
}
hash := udpPacket.L4FlowHash()
// conntrack
d.udpNetOrigConnectionTracker.AddOrUpdate(hash, conn)
d.udpAppReplyConnectionTracker.AddOrUpdate(udpPacket.L4ReverseFlowHash(), conn)
// Record actions
conn.ReportFlowPolicy = report
conn.PacketFlowPolicy = pkt
return pkt, claims, nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processNetworkUDPSynPacket",
"(",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"conn",
"*",
"connection",
".",
"UDPConnection",
",",
"udpPacket",
"*",
"packet",
".",
"Packet",
")",
"(",
"action",
"interface",
"... | // processNetworkUDPSynPacket processes a syn packet arriving from the network | [
"processNetworkUDPSynPacket",
"processes",
"a",
"syn",
"packet",
"arriving",
"from",
"the",
"network"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L537-L576 |
6,833 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | sendUDPFinPacket | func (d *Datapath) sendUDPFinPacket(udpPacket *packet.Packet) (err error) {
// Create UDP Option
udpOptions := packet.CreateUDPAuthMarker(packet.UDPFinAckMask)
udpPacket.CreateReverseFlowPacket(udpPacket.SourceAddress(), udpPacket.SourcePort())
// Attach the UDP data and token
udpPacket.UDPTokenAttach(udpOptions, []byte{})
zap.L().Info("Sending udp fin ack packet", zap.String("packet", udpPacket.L4FlowHash()))
// no need for retransmits here.
err = d.udpSocketWriter.WriteSocket(udpPacket.GetBuffer(0))
if err != nil {
zap.L().Debug("Unable to send fin packet on raw socket", zap.Error(err))
return err
}
return nil
} | go | func (d *Datapath) sendUDPFinPacket(udpPacket *packet.Packet) (err error) {
// Create UDP Option
udpOptions := packet.CreateUDPAuthMarker(packet.UDPFinAckMask)
udpPacket.CreateReverseFlowPacket(udpPacket.SourceAddress(), udpPacket.SourcePort())
// Attach the UDP data and token
udpPacket.UDPTokenAttach(udpOptions, []byte{})
zap.L().Info("Sending udp fin ack packet", zap.String("packet", udpPacket.L4FlowHash()))
// no need for retransmits here.
err = d.udpSocketWriter.WriteSocket(udpPacket.GetBuffer(0))
if err != nil {
zap.L().Debug("Unable to send fin packet on raw socket", zap.Error(err))
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"sendUDPFinPacket",
"(",
"udpPacket",
"*",
"packet",
".",
"Packet",
")",
"(",
"err",
"error",
")",
"{",
"// Create UDP Option",
"udpOptions",
":=",
"packet",
".",
"CreateUDPAuthMarker",
"(",
"packet",
".",
"UDPFinAckMask... | // sendUDPFinPacket sends a Fin packet to Peer. | [
"sendUDPFinPacket",
"sends",
"a",
"Fin",
"packet",
"to",
"Peer",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L638-L657 |
6,834 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/datapath_udp.go | processUDPFinPacket | func (d *Datapath) processUDPFinPacket(udpPacket *packet.Packet) (err error) { // nolint
// add it to the udp fin cache. If we have already received the fin packet
// for this flow. There is no need to change the connmark label again.
if d.udpFinPacketTracker.AddOrUpdate(udpPacket.L4ReverseFlowHash(), true) {
return nil
}
// clear cache entries.
if err := d.udpAppOrigConnectionTracker.Remove(udpPacket.L4ReverseFlowHash()); err != nil {
zap.L().Debug("Failed to clean cache udpappOrigConnectionTracker", zap.Error(err))
}
if err := d.udpSourcePortConnectionCache.Remove(udpPacket.SourcePortHash(packet.PacketTypeNetwork)); err != nil {
zap.L().Debug("Failed to clean cache udpsourcePortConnectionCache", zap.Error(err))
}
zap.L().Debug("Updating the connmark label", zap.String("flow", udpPacket.L4FlowHash()))
if err = d.conntrack.UpdateNetworkFlowMark(
udpPacket.SourceAddress(),
udpPacket.DestinationAddress(),
udpPacket.IPProto(),
udpPacket.SourcePort(),
udpPacket.DestPort(),
constants.DeleteConnmark,
); err != nil {
zap.L().Error("Failed to update conntrack table for flow to terminate connection",
zap.String("app-conn", udpPacket.L4FlowHash()),
zap.Error(err),
)
}
return nil
} | go | func (d *Datapath) processUDPFinPacket(udpPacket *packet.Packet) (err error) { // nolint
// add it to the udp fin cache. If we have already received the fin packet
// for this flow. There is no need to change the connmark label again.
if d.udpFinPacketTracker.AddOrUpdate(udpPacket.L4ReverseFlowHash(), true) {
return nil
}
// clear cache entries.
if err := d.udpAppOrigConnectionTracker.Remove(udpPacket.L4ReverseFlowHash()); err != nil {
zap.L().Debug("Failed to clean cache udpappOrigConnectionTracker", zap.Error(err))
}
if err := d.udpSourcePortConnectionCache.Remove(udpPacket.SourcePortHash(packet.PacketTypeNetwork)); err != nil {
zap.L().Debug("Failed to clean cache udpsourcePortConnectionCache", zap.Error(err))
}
zap.L().Debug("Updating the connmark label", zap.String("flow", udpPacket.L4FlowHash()))
if err = d.conntrack.UpdateNetworkFlowMark(
udpPacket.SourceAddress(),
udpPacket.DestinationAddress(),
udpPacket.IPProto(),
udpPacket.SourcePort(),
udpPacket.DestPort(),
constants.DeleteConnmark,
); err != nil {
zap.L().Error("Failed to update conntrack table for flow to terminate connection",
zap.String("app-conn", udpPacket.L4FlowHash()),
zap.Error(err),
)
}
return nil
} | [
"func",
"(",
"d",
"*",
"Datapath",
")",
"processUDPFinPacket",
"(",
"udpPacket",
"*",
"packet",
".",
"Packet",
")",
"(",
"err",
"error",
")",
"{",
"// nolint",
"// add it to the udp fin cache. If we have already received the fin packet",
"// for this flow. There is no need ... | // Update the udp fin cache and delete the connmark. | [
"Update",
"the",
"udp",
"fin",
"cache",
"and",
"delete",
"the",
"connmark",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/datapath_udp.go#L660-L693 |
6,835 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | newRemoteEnforcer | func newRemoteEnforcer(
ctx context.Context,
cancel context.CancelFunc,
service packetprocessor.PacketProcessor,
rpcHandle rpcwrapper.RPCServer,
secret string,
statsClient statsclient.StatsClient,
collector statscollector.Collector,
debugClient debugclient.DebugClient,
) (*RemoteEnforcer, error) {
var err error
if collector == nil {
collector = statscollector.NewCollector()
}
if statsClient == nil {
statsClient, err = statsclient.NewStatsClient(collector)
if err != nil {
return nil, err
}
}
if debugClient == nil {
debugClient, err = debugclient.NewDebugClient(collector)
if err != nil {
return nil, err
}
}
procMountPoint := os.Getenv(constants.EnvMountPoint)
if procMountPoint == "" {
procMountPoint = constants.DefaultProcMountPoint
}
return &RemoteEnforcer{
collector: collector,
service: service,
rpcSecret: secret,
rpcHandle: rpcHandle,
procMountPoint: procMountPoint,
statsClient: statsClient,
debugClient: debugClient,
ctx: ctx,
cancel: cancel,
exit: make(chan bool),
}, nil
} | go | func newRemoteEnforcer(
ctx context.Context,
cancel context.CancelFunc,
service packetprocessor.PacketProcessor,
rpcHandle rpcwrapper.RPCServer,
secret string,
statsClient statsclient.StatsClient,
collector statscollector.Collector,
debugClient debugclient.DebugClient,
) (*RemoteEnforcer, error) {
var err error
if collector == nil {
collector = statscollector.NewCollector()
}
if statsClient == nil {
statsClient, err = statsclient.NewStatsClient(collector)
if err != nil {
return nil, err
}
}
if debugClient == nil {
debugClient, err = debugclient.NewDebugClient(collector)
if err != nil {
return nil, err
}
}
procMountPoint := os.Getenv(constants.EnvMountPoint)
if procMountPoint == "" {
procMountPoint = constants.DefaultProcMountPoint
}
return &RemoteEnforcer{
collector: collector,
service: service,
rpcSecret: secret,
rpcHandle: rpcHandle,
procMountPoint: procMountPoint,
statsClient: statsClient,
debugClient: debugClient,
ctx: ctx,
cancel: cancel,
exit: make(chan bool),
}, nil
} | [
"func",
"newRemoteEnforcer",
"(",
"ctx",
"context",
".",
"Context",
",",
"cancel",
"context",
".",
"CancelFunc",
",",
"service",
"packetprocessor",
".",
"PacketProcessor",
",",
"rpcHandle",
"rpcwrapper",
".",
"RPCServer",
",",
"secret",
"string",
",",
"statsClient... | // newRemoteEnforcer starts a new server | [
"newRemoteEnforcer",
"starts",
"a",
"new",
"server"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L47-L94 |
6,836 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | Enforce | func (s *RemoteEnforcer) Enforce(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "enforce message auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
payload, ok := req.Payload.(rpcwrapper.EnforcePayload)
if !ok {
resp.Status = "invalid enforcer payload"
return fmt.Errorf(resp.Status)
}
plc, err := payload.Policy.ToPrivatePolicy(true)
if err != nil {
return err
}
puInfo := &policy.PUInfo{
ContextID: payload.ContextID,
Policy: plc,
Runtime: policy.NewPURuntimeWithDefaults(),
}
if s.enforcer == nil || s.supervisor == nil {
resp.Status = "enforcer not initialized - cannot enforce"
return fmt.Errorf(resp.Status)
}
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.supervisor.Supervise(payload.ContextID, puInfo); err != nil {
resp.Status = err.Error()
return err
}
if err = s.enforcer.Enforce(payload.ContextID, puInfo); err != nil {
resp.Status = err.Error()
return err
}
resp.Status = ""
return nil
} | go | func (s *RemoteEnforcer) Enforce(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "enforce message auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
payload, ok := req.Payload.(rpcwrapper.EnforcePayload)
if !ok {
resp.Status = "invalid enforcer payload"
return fmt.Errorf(resp.Status)
}
plc, err := payload.Policy.ToPrivatePolicy(true)
if err != nil {
return err
}
puInfo := &policy.PUInfo{
ContextID: payload.ContextID,
Policy: plc,
Runtime: policy.NewPURuntimeWithDefaults(),
}
if s.enforcer == nil || s.supervisor == nil {
resp.Status = "enforcer not initialized - cannot enforce"
return fmt.Errorf(resp.Status)
}
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.supervisor.Supervise(payload.ContextID, puInfo); err != nil {
resp.Status = err.Error()
return err
}
if err = s.enforcer.Enforce(payload.ContextID, puInfo); err != nil {
resp.Status = err.Error()
return err
}
resp.Status = ""
return nil
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"Enforce",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"if",
"!",
"s",
".",
"rpcHandle",
".",
"CheckValidity",
"(",
"&",
"req",
",",
"s",
... | // Enforce this method calls the enforce method on the enforcer created during initenforcer | [
"Enforce",
"this",
"method",
"calls",
"the",
"enforce",
"method",
"on",
"the",
"enforcer",
"created",
"during",
"initenforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L165-L218 |
6,837 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | Unenforce | func (s *RemoteEnforcer) Unenforce(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "unenforce message auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
s.statsClient.SendStats()
payload, ok := req.Payload.(rpcwrapper.UnEnforcePayload)
if !ok {
resp.Status = "invalid unenforcer payload"
return fmt.Errorf(resp.Status)
}
var err error
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.supervisor.Unsupervise(payload.ContextID); err != nil {
resp.Status = err.Error()
return fmt.Errorf("unable to clean supervisor: %s", err)
}
if err = s.enforcer.Unenforce(payload.ContextID); err != nil {
resp.Status = err.Error()
return fmt.Errorf("unable to stop enforcer: %s", err)
}
return nil
} | go | func (s *RemoteEnforcer) Unenforce(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "unenforce message auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
s.statsClient.SendStats()
payload, ok := req.Payload.(rpcwrapper.UnEnforcePayload)
if !ok {
resp.Status = "invalid unenforcer payload"
return fmt.Errorf(resp.Status)
}
var err error
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.supervisor.Unsupervise(payload.ContextID); err != nil {
resp.Status = err.Error()
return fmt.Errorf("unable to clean supervisor: %s", err)
}
if err = s.enforcer.Unenforce(payload.ContextID); err != nil {
resp.Status = err.Error()
return fmt.Errorf("unable to stop enforcer: %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"Unenforce",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"if",
"!",
"s",
".",
"rpcHandle",
".",
"CheckValidity",
"(",
"&",
"req",
",",
"s",
... | // Unenforce this method calls the unenforce method on the enforcer created from initenforcer | [
"Unenforce",
"this",
"method",
"calls",
"the",
"unenforce",
"method",
"on",
"the",
"enforcer",
"created",
"from",
"initenforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L221-L260 |
6,838 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | SetTargetNetworks | func (s *RemoteEnforcer) SetTargetNetworks(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
var err error
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "SetTargetNetworks message auth failed" //nolint
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
if s.enforcer == nil || s.supervisor == nil {
return fmt.Errorf(resp.Status)
}
payload := req.Payload.(rpcwrapper.SetTargetNetworksPayload)
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.enforcer.SetTargetNetworks(payload.Configuration); err != nil {
return err
}
err = s.supervisor.SetTargetNetworks(payload.Configuration)
return err
} | go | func (s *RemoteEnforcer) SetTargetNetworks(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
var err error
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "SetTargetNetworks message auth failed" //nolint
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
if s.enforcer == nil || s.supervisor == nil {
return fmt.Errorf(resp.Status)
}
payload := req.Payload.(rpcwrapper.SetTargetNetworksPayload)
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
if err = s.enforcer.SetTargetNetworks(payload.Configuration); err != nil {
return err
}
err = s.supervisor.SetTargetNetworks(payload.Configuration)
return err
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"SetTargetNetworks",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"s",
".",
"rpcHandle",
".",
"CheckVal... | // SetTargetNetworks calls the same method on the actual enforcer | [
"SetTargetNetworks",
"calls",
"the",
"same",
"method",
"on",
"the",
"actual",
"enforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L263-L295 |
6,839 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | EnforcerExit | func (s *RemoteEnforcer) EnforcerExit(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
s.cleanup()
s.exit <- true
return nil
} | go | func (s *RemoteEnforcer) EnforcerExit(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
s.cleanup()
s.exit <- true
return nil
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"EnforcerExit",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"s",
".",
"cleanup",
"(",
")",
"\n\n",
"s",
".",
"exit",
"<-",
"true",
"\n\n",
... | // EnforcerExit is processing messages from the remote that are requesting an exit. In this
// case we simply cancel the context. | [
"EnforcerExit",
"is",
"processing",
"messages",
"from",
"the",
"remote",
"that",
"are",
"requesting",
"an",
"exit",
".",
"In",
"this",
"case",
"we",
"simply",
"cancel",
"the",
"context",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L299-L306 |
6,840 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | UpdateSecrets | func (s *RemoteEnforcer) UpdateSecrets(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
var err error
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "updatesecrets auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
if s.enforcer == nil {
return fmt.Errorf(resp.Status)
}
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
payload := req.Payload.(rpcwrapper.UpdateSecretsPayload)
s.secrets, err = secrets.NewSecrets(payload.Secrets)
if err != nil {
return err
}
err = s.enforcer.UpdateSecrets(s.secrets)
return err
} | go | func (s *RemoteEnforcer) UpdateSecrets(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
var err error
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "updatesecrets auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
if s.enforcer == nil {
return fmt.Errorf(resp.Status)
}
// If any error happens, cleanup everything on exit so that we can recover
// by launcing a new remote.
defer func() {
if err != nil {
s.cleanup()
}
}()
payload := req.Payload.(rpcwrapper.UpdateSecretsPayload)
s.secrets, err = secrets.NewSecrets(payload.Secrets)
if err != nil {
return err
}
err = s.enforcer.UpdateSecrets(s.secrets)
return err
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"UpdateSecrets",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"s",
".",
"rpcHandle",
".",
"CheckValidit... | // UpdateSecrets updates the secrets used by the remote enforcer | [
"UpdateSecrets",
"updates",
"the",
"secrets",
"used",
"by",
"the",
"remote",
"enforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L309-L339 |
6,841 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | EnableIPTablesPacketTracing | func (s *RemoteEnforcer) EnableIPTablesPacketTracing(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "enable iptable packet tracing auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
payload := req.Payload.(rpcwrapper.EnableIPTablesPacketTracingPayLoad)
if err := s.supervisor.EnableIPTablesPacketTracing(context.Background(), payload.ContextID, payload.Interval); err != nil {
resp.Status = err.Error()
return err
}
resp.Status = ""
return nil
} | go | func (s *RemoteEnforcer) EnableIPTablesPacketTracing(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !s.rpcHandle.CheckValidity(&req, s.rpcSecret) {
resp.Status = "enable iptable packet tracing auth failed"
return fmt.Errorf(resp.Status)
}
cmdLock.Lock()
defer cmdLock.Unlock()
payload := req.Payload.(rpcwrapper.EnableIPTablesPacketTracingPayLoad)
if err := s.supervisor.EnableIPTablesPacketTracing(context.Background(), payload.ContextID, payload.Interval); err != nil {
resp.Status = err.Error()
return err
}
resp.Status = ""
return nil
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"EnableIPTablesPacketTracing",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"if",
"!",
"s",
".",
"rpcHandle",
".",
"CheckValidity",
"(",
"&",
"re... | // EnableIPTablesPacketTracing enables iptables trace packet tracing | [
"EnableIPTablesPacketTracing",
"enables",
"iptables",
"trace",
"packet",
"tracing"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L364-L383 |
6,842 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | setupEnforcer | func (s *RemoteEnforcer) setupEnforcer(payload *rpcwrapper.InitRequestPayload) error {
var err error
s.secrets, err = secrets.NewSecrets(payload.Secrets)
if err != nil {
return err
}
if s.enforcer, err = createEnforcer(
payload.MutualAuth,
payload.FqConfig,
s.collector,
s.service,
s.secrets,
payload.ServerID,
payload.Validity,
constants.RemoteContainer,
s.procMountPoint,
payload.ExternalIPCacheTimeout,
payload.PacketLogs,
payload.Configuration,
); err != nil || s.enforcer == nil {
return fmt.Errorf("Error while initializing remote enforcer, %s", err)
}
return nil
} | go | func (s *RemoteEnforcer) setupEnforcer(payload *rpcwrapper.InitRequestPayload) error {
var err error
s.secrets, err = secrets.NewSecrets(payload.Secrets)
if err != nil {
return err
}
if s.enforcer, err = createEnforcer(
payload.MutualAuth,
payload.FqConfig,
s.collector,
s.service,
s.secrets,
payload.ServerID,
payload.Validity,
constants.RemoteContainer,
s.procMountPoint,
payload.ExternalIPCacheTimeout,
payload.PacketLogs,
payload.Configuration,
); err != nil || s.enforcer == nil {
return fmt.Errorf("Error while initializing remote enforcer, %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"setupEnforcer",
"(",
"payload",
"*",
"rpcwrapper",
".",
"InitRequestPayload",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"s",
".",
"secrets",
",",
"err",
"=",
"secrets",
".",
"NewSecrets",
"(",
"payload... | // setup an enforcer | [
"setup",
"an",
"enforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L386-L413 |
6,843 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | cleanup | func (s *RemoteEnforcer) cleanup() {
if s.supervisor != nil {
if err := s.supervisor.CleanUp(); err != nil {
zap.L().Error("unable to clean supervisor state", zap.Error(err))
}
}
if s.enforcer != nil {
if err := s.enforcer.CleanUp(); err != nil {
zap.L().Error("unable to clean enforcer state", zap.Error(err))
}
}
if s.service != nil {
if err := s.service.Stop(); err != nil {
zap.L().Error("unable to clean service state", zap.Error(err))
}
}
s.cancel()
} | go | func (s *RemoteEnforcer) cleanup() {
if s.supervisor != nil {
if err := s.supervisor.CleanUp(); err != nil {
zap.L().Error("unable to clean supervisor state", zap.Error(err))
}
}
if s.enforcer != nil {
if err := s.enforcer.CleanUp(); err != nil {
zap.L().Error("unable to clean enforcer state", zap.Error(err))
}
}
if s.service != nil {
if err := s.service.Stop(); err != nil {
zap.L().Error("unable to clean service state", zap.Error(err))
}
}
s.cancel()
} | [
"func",
"(",
"s",
"*",
"RemoteEnforcer",
")",
"cleanup",
"(",
")",
"{",
"if",
"s",
".",
"supervisor",
"!=",
"nil",
"{",
"if",
"err",
":=",
"s",
".",
"supervisor",
".",
"CleanUp",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")"... | // cleanup cleans all the acls and any state of the local enforcer. | [
"cleanup",
"cleans",
"all",
"the",
"acls",
"and",
"any",
"state",
"of",
"the",
"local",
"enforcer",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L433-L454 |
6,844 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | LaunchRemoteEnforcer | func LaunchRemoteEnforcer(service packetprocessor.PacketProcessor) error {
// Before doing anything validate that we are in the right namespace.
if err := validateNamespace(); err != nil {
return err
}
ctx, cancelMainCtx := context.WithCancel(context.Background())
defer cancelMainCtx()
namedPipe := os.Getenv(constants.EnvContextSocket)
secret := os.Getenv(constants.EnvRPCClientSecret)
if secret == "" {
zap.L().Fatal("No secret found")
}
flag := unix.SIGHUP
if err := unix.Prctl(unix.PR_SET_PDEATHSIG, uintptr(flag), 0, 0, 0); err != nil {
return err
}
rpcHandle := rpcwrapper.NewRPCServer()
re, err := newRemoteEnforcer(ctx, cancelMainCtx, service, rpcHandle, secret, nil, nil, nil)
if err != nil {
return err
}
go func() {
if err := rpcHandle.StartServer(ctx, "unix", namedPipe, re); err != nil {
zap.L().Fatal("Failed to start the server", zap.Error(err))
}
}()
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT)
select {
case <-c:
re.cleanup()
case <-re.exit:
zap.L().Info("Remote enforcer exiting ...")
}
return nil
} | go | func LaunchRemoteEnforcer(service packetprocessor.PacketProcessor) error {
// Before doing anything validate that we are in the right namespace.
if err := validateNamespace(); err != nil {
return err
}
ctx, cancelMainCtx := context.WithCancel(context.Background())
defer cancelMainCtx()
namedPipe := os.Getenv(constants.EnvContextSocket)
secret := os.Getenv(constants.EnvRPCClientSecret)
if secret == "" {
zap.L().Fatal("No secret found")
}
flag := unix.SIGHUP
if err := unix.Prctl(unix.PR_SET_PDEATHSIG, uintptr(flag), 0, 0, 0); err != nil {
return err
}
rpcHandle := rpcwrapper.NewRPCServer()
re, err := newRemoteEnforcer(ctx, cancelMainCtx, service, rpcHandle, secret, nil, nil, nil)
if err != nil {
return err
}
go func() {
if err := rpcHandle.StartServer(ctx, "unix", namedPipe, re); err != nil {
zap.L().Fatal("Failed to start the server", zap.Error(err))
}
}()
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT)
select {
case <-c:
re.cleanup()
case <-re.exit:
zap.L().Info("Remote enforcer exiting ...")
}
return nil
} | [
"func",
"LaunchRemoteEnforcer",
"(",
"service",
"packetprocessor",
".",
"PacketProcessor",
")",
"error",
"{",
"// Before doing anything validate that we are in the right namespace.",
"if",
"err",
":=",
"validateNamespace",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",... | // LaunchRemoteEnforcer launches a remote enforcer | [
"LaunchRemoteEnforcer",
"launches",
"a",
"remote",
"enforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L457-L503 |
6,845 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_linux.go | getCEnvVariable | func getCEnvVariable(name string) string {
val := C.getenv(C.CString(name))
if val == nil {
return ""
}
return C.GoString(val)
} | go | func getCEnvVariable(name string) string {
val := C.getenv(C.CString(name))
if val == nil {
return ""
}
return C.GoString(val)
} | [
"func",
"getCEnvVariable",
"(",
"name",
"string",
")",
"string",
"{",
"val",
":=",
"C",
".",
"getenv",
"(",
"C",
".",
"CString",
"(",
"name",
")",
")",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"C",
"... | // getCEnvVariable returns an environment variable set in the c context | [
"getCEnvVariable",
"returns",
"an",
"environment",
"variable",
"set",
"in",
"the",
"c",
"context"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_linux.go#L506-L514 |
6,846 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | NewAPICache | func NewAPICache(rules []*policy.HTTPRule, id string, external bool) *APICache {
a := &APICache{
methodRoots: map[string]*node{},
ID: id,
External: external,
}
for _, rule := range rules {
sc := &scopeRule{
rule: rule,
}
for _, method := range rule.Methods {
if _, ok := a.methodRoots[method]; !ok {
a.methodRoots[method] = &node{}
}
for _, uri := range rule.URIs {
insert(a.methodRoots[method], uri, sc)
}
}
}
return a
} | go | func NewAPICache(rules []*policy.HTTPRule, id string, external bool) *APICache {
a := &APICache{
methodRoots: map[string]*node{},
ID: id,
External: external,
}
for _, rule := range rules {
sc := &scopeRule{
rule: rule,
}
for _, method := range rule.Methods {
if _, ok := a.methodRoots[method]; !ok {
a.methodRoots[method] = &node{}
}
for _, uri := range rule.URIs {
insert(a.methodRoots[method], uri, sc)
}
}
}
return a
} | [
"func",
"NewAPICache",
"(",
"rules",
"[",
"]",
"*",
"policy",
".",
"HTTPRule",
",",
"id",
"string",
",",
"external",
"bool",
")",
"*",
"APICache",
"{",
"a",
":=",
"&",
"APICache",
"{",
"methodRoots",
":",
"map",
"[",
"string",
"]",
"*",
"node",
"{",
... | // NewAPICache creates a new API cache | [
"NewAPICache",
"creates",
"a",
"new",
"API",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L25-L47 |
6,847 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | FindRule | func (c *APICache) FindRule(verb, uri string) (bool, *policy.HTTPRule) {
found, rule := c.Find(verb, uri)
if rule == nil {
return found, nil
}
if policyRule, ok := rule.(*scopeRule); ok {
return found, policyRule.rule
}
return false, nil
} | go | func (c *APICache) FindRule(verb, uri string) (bool, *policy.HTTPRule) {
found, rule := c.Find(verb, uri)
if rule == nil {
return found, nil
}
if policyRule, ok := rule.(*scopeRule); ok {
return found, policyRule.rule
}
return false, nil
} | [
"func",
"(",
"c",
"*",
"APICache",
")",
"FindRule",
"(",
"verb",
",",
"uri",
"string",
")",
"(",
"bool",
",",
"*",
"policy",
".",
"HTTPRule",
")",
"{",
"found",
",",
"rule",
":=",
"c",
".",
"Find",
"(",
"verb",
",",
"uri",
")",
"\n",
"if",
"rul... | // FindRule finds a rule in the APICache without validating scopes | [
"FindRule",
"finds",
"a",
"rule",
"in",
"the",
"APICache",
"without",
"validating",
"scopes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L50-L59 |
6,848 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | FindAndMatchScope | func (c *APICache) FindAndMatchScope(verb, uri string, attributes []string) (bool, bool) {
found, rule := c.Find(verb, uri)
if !found || rule == nil {
return false, false
}
policyRule, ok := rule.(*scopeRule)
if !ok {
return false, false
}
if policyRule.rule.Public {
return true, true
}
return c.MatchClaims(policyRule.rule.ClaimMatchingRules, attributes), false
} | go | func (c *APICache) FindAndMatchScope(verb, uri string, attributes []string) (bool, bool) {
found, rule := c.Find(verb, uri)
if !found || rule == nil {
return false, false
}
policyRule, ok := rule.(*scopeRule)
if !ok {
return false, false
}
if policyRule.rule.Public {
return true, true
}
return c.MatchClaims(policyRule.rule.ClaimMatchingRules, attributes), false
} | [
"func",
"(",
"c",
"*",
"APICache",
")",
"FindAndMatchScope",
"(",
"verb",
",",
"uri",
"string",
",",
"attributes",
"[",
"]",
"string",
")",
"(",
"bool",
",",
"bool",
")",
"{",
"found",
",",
"rule",
":=",
"c",
".",
"Find",
"(",
"verb",
",",
"uri",
... | // FindAndMatchScope finds the rule and returns true only if the scope matches
// as well. It also returns true of this was a public rule, allowing the callers
// to decide how to present the data or potentially what to do if authorization
// fails. | [
"FindAndMatchScope",
"finds",
"the",
"rule",
"and",
"returns",
"true",
"only",
"if",
"the",
"scope",
"matches",
"as",
"well",
".",
"It",
"also",
"returns",
"true",
"of",
"this",
"was",
"a",
"public",
"rule",
"allowing",
"the",
"callers",
"to",
"decide",
"h... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L65-L78 |
6,849 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | MatchClaims | func (c *APICache) MatchClaims(rules [][]string, claims []string) bool {
claimsMap := map[string]struct{}{}
for _, claim := range claims {
claimsMap[claim] = struct{}{}
}
var matched int
for _, clause := range rules {
matched = len(clause)
for _, claim := range clause {
if _, ok := claimsMap[claim]; ok {
matched--
}
if matched == 0 {
return true
}
}
}
return false
} | go | func (c *APICache) MatchClaims(rules [][]string, claims []string) bool {
claimsMap := map[string]struct{}{}
for _, claim := range claims {
claimsMap[claim] = struct{}{}
}
var matched int
for _, clause := range rules {
matched = len(clause)
for _, claim := range clause {
if _, ok := claimsMap[claim]; ok {
matched--
}
if matched == 0 {
return true
}
}
}
return false
} | [
"func",
"(",
"c",
"*",
"APICache",
")",
"MatchClaims",
"(",
"rules",
"[",
"]",
"[",
"]",
"string",
",",
"claims",
"[",
"]",
"string",
")",
"bool",
"{",
"claimsMap",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
... | // MatchClaims receives a set of claim matchibg rules and a set of claims
// and returns true of the claims match the rules. | [
"MatchClaims",
"receives",
"a",
"set",
"of",
"claim",
"matchibg",
"rules",
"and",
"a",
"set",
"of",
"claims",
"and",
"returns",
"true",
"of",
"the",
"claims",
"match",
"the",
"rules",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L82-L102 |
6,850 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | Find | func (c *APICache) Find(verb, uri string) (bool, interface{}) {
root, ok := c.methodRoots[verb]
if !ok {
return false, nil
}
return search(root, uri)
} | go | func (c *APICache) Find(verb, uri string) (bool, interface{}) {
root, ok := c.methodRoots[verb]
if !ok {
return false, nil
}
return search(root, uri)
} | [
"func",
"(",
"c",
"*",
"APICache",
")",
"Find",
"(",
"verb",
",",
"uri",
"string",
")",
"(",
"bool",
",",
"interface",
"{",
"}",
")",
"{",
"root",
",",
"ok",
":=",
"c",
".",
"methodRoots",
"[",
"verb",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",... | // Find finds a URI in the cache and returns true and the data if found.
// If not found it returns false. | [
"Find",
"finds",
"a",
"URI",
"in",
"the",
"cache",
"and",
"returns",
"true",
"and",
"the",
"data",
"if",
"found",
".",
"If",
"not",
"found",
"it",
"returns",
"false",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L106-L112 |
6,851 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | parse | func parse(s string) (string, string) {
if s == "/" {
return s, ""
}
for i := 1; i < len(s); i++ {
if s[i] == '/' {
return s[0:i], s[i:]
}
}
return s, ""
} | go | func parse(s string) (string, string) {
if s == "/" {
return s, ""
}
for i := 1; i < len(s); i++ {
if s[i] == '/' {
return s[0:i], s[i:]
}
}
return s, ""
} | [
"func",
"parse",
"(",
"s",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"s",
",",
"\"",
"\"",
"\n",
"}",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"len",
"(",
"s",
")",
";",
"i",
"++... | // parse parses a URI and splits into prefix, suffix | [
"parse",
"parses",
"a",
"URI",
"and",
"splits",
"into",
"prefix",
"suffix"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L115-L126 |
6,852 | aporeto-inc/trireme-lib | controller/pkg/urisearch/urisearch.go | insert | func insert(n *node, api string, data interface{}) {
if len(api) == 0 {
n.data = data
n.leaf = true
return
}
prefix, suffix := parse(api)
// root node or terminal node
if prefix == "/" {
n.data = data
n.leaf = true
return
}
if n.children == nil {
n.children = map[string]*node{}
}
// If there is no child, add the new child.
next, ok := n.children[prefix]
if !ok {
next = &node{}
n.children[prefix] = next
}
insert(next, suffix, data)
} | go | func insert(n *node, api string, data interface{}) {
if len(api) == 0 {
n.data = data
n.leaf = true
return
}
prefix, suffix := parse(api)
// root node or terminal node
if prefix == "/" {
n.data = data
n.leaf = true
return
}
if n.children == nil {
n.children = map[string]*node{}
}
// If there is no child, add the new child.
next, ok := n.children[prefix]
if !ok {
next = &node{}
n.children[prefix] = next
}
insert(next, suffix, data)
} | [
"func",
"insert",
"(",
"n",
"*",
"node",
",",
"api",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"{",
"if",
"len",
"(",
"api",
")",
"==",
"0",
"{",
"n",
".",
"data",
"=",
"data",
"\n",
"n",
".",
"leaf",
"=",
"true",
"\n",
"return",
"\n... | // insert adds an api to the api cache | [
"insert",
"adds",
"an",
"api",
"to",
"the",
"api",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/urisearch/urisearch.go#L129-L157 |
6,853 | aporeto-inc/trireme-lib | monitor/internal/docker/helpers.go | getPausePUID | func getPausePUID(extensions policy.ExtendedMap) string {
if extensions == nil {
return ""
}
if puid, ok := extensions.Get(constants.DockerHostPUID); ok {
zap.L().Debug("puid of pause container is", zap.String("puid", puid))
return puid
}
return ""
} | go | func getPausePUID(extensions policy.ExtendedMap) string {
if extensions == nil {
return ""
}
if puid, ok := extensions.Get(constants.DockerHostPUID); ok {
zap.L().Debug("puid of pause container is", zap.String("puid", puid))
return puid
}
return ""
} | [
"func",
"getPausePUID",
"(",
"extensions",
"policy",
".",
"ExtendedMap",
")",
"string",
"{",
"if",
"extensions",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"puid",
",",
"ok",
":=",
"extensions",
".",
"Get",
"(",
"constants",
".",
... | // getPausePUID returns puid of pause container. | [
"getPausePUID",
"returns",
"puid",
"of",
"pause",
"container",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/helpers.go#L11-L23 |
6,854 | aporeto-inc/trireme-lib | monitor/internal/docker/helpers.go | policyExtensions | func policyExtensions(runtime policy.RuntimeReader) (extensions policy.ExtendedMap) {
if runtime == nil {
return nil
}
if runtime.Options().PolicyExtensions == nil {
return nil
}
if extensions, ok := runtime.Options().PolicyExtensions.(policy.ExtendedMap); ok {
return extensions
}
return nil
} | go | func policyExtensions(runtime policy.RuntimeReader) (extensions policy.ExtendedMap) {
if runtime == nil {
return nil
}
if runtime.Options().PolicyExtensions == nil {
return nil
}
if extensions, ok := runtime.Options().PolicyExtensions.(policy.ExtendedMap); ok {
return extensions
}
return nil
} | [
"func",
"policyExtensions",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"(",
"extensions",
"policy",
".",
"ExtendedMap",
")",
"{",
"if",
"runtime",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"runtime",
".",
"Options",
"(",
")",
... | // PolicyExtensions retrieves policy extensions | [
"PolicyExtensions",
"retrieves",
"policy",
"extensions"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/helpers.go#L26-L40 |
6,855 | aporeto-inc/trireme-lib | monitor/internal/docker/helpers.go | isHostNetworkContainer | func isHostNetworkContainer(runtime policy.RuntimeReader) bool {
return runtime.PUType() == common.LinuxProcessPU || (getPausePUID(policyExtensions(runtime)) != "")
} | go | func isHostNetworkContainer(runtime policy.RuntimeReader) bool {
return runtime.PUType() == common.LinuxProcessPU || (getPausePUID(policyExtensions(runtime)) != "")
} | [
"func",
"isHostNetworkContainer",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"bool",
"{",
"return",
"runtime",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"LinuxProcessPU",
"||",
"(",
"getPausePUID",
"(",
"policyExtensions",
"(",
"runtime",
")",
")... | // IsHostNetworkContainer returns true if container has hostnetwork set
// to true or is linked to container with hostnetwork set to true. | [
"IsHostNetworkContainer",
"returns",
"true",
"if",
"container",
"has",
"hostnetwork",
"set",
"to",
"true",
"or",
"is",
"linked",
"to",
"container",
"with",
"hostnetwork",
"set",
"to",
"true",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/helpers.go#L44-L47 |
6,856 | aporeto-inc/trireme-lib | monitor/internal/docker/helpers.go | isKubernetesContainer | func isKubernetesContainer(labels map[string]string) bool {
if _, ok := labels[constants.K8sPodNamespace]; ok {
return true
}
return false
} | go | func isKubernetesContainer(labels map[string]string) bool {
if _, ok := labels[constants.K8sPodNamespace]; ok {
return true
}
return false
} | [
"func",
"isKubernetesContainer",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"labels",
"[",
"constants",
".",
"K8sPodNamespace",
"]",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"fa... | // IsKubernetesContainer checks if the container is in K8s. | [
"IsKubernetesContainer",
"checks",
"if",
"the",
"container",
"is",
"in",
"K8s",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/helpers.go#L50-L56 |
6,857 | aporeto-inc/trireme-lib | monitor/internal/docker/helpers.go | kubePodIdentifier | func kubePodIdentifier(labels map[string]string) string {
if !isKubernetesContainer(labels) {
return ""
}
podName := ""
podNamespace := ""
podNamespace, ok := labels[constants.K8sPodNamespace]
if !ok {
podNamespace = ""
}
podName, ok = labels[constants.K8sPodName]
if !ok {
podName = ""
}
if podName == "" || podNamespace == "" {
zap.L().Warn("K8s pod does not have podname/podnamespace labels")
return ""
}
return podNamespace + "/" + podName
} | go | func kubePodIdentifier(labels map[string]string) string {
if !isKubernetesContainer(labels) {
return ""
}
podName := ""
podNamespace := ""
podNamespace, ok := labels[constants.K8sPodNamespace]
if !ok {
podNamespace = ""
}
podName, ok = labels[constants.K8sPodName]
if !ok {
podName = ""
}
if podName == "" || podNamespace == "" {
zap.L().Warn("K8s pod does not have podname/podnamespace labels")
return ""
}
return podNamespace + "/" + podName
} | [
"func",
"kubePodIdentifier",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"string",
"{",
"if",
"!",
"isKubernetesContainer",
"(",
"labels",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"podName",
":=",
"\"",
"\"",
"\n",
"podNamespace",
":... | // KubePodIdentifier returns identifier for K8s pod. | [
"KubePodIdentifier",
"returns",
"identifier",
"for",
"K8s",
"pod",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/docker/helpers.go#L59-L83 |
6,858 | aporeto-inc/trireme-lib | controller/internal/enforcer/lookup/lookup.go | NewPolicyDB | func NewPolicyDB() (m *PolicyDB) {
m = &PolicyDB{
numberOfPolicies: 0,
equalPrefixes: map[string]intList{},
equalMapTable: map[string]map[string][]*ForwardingPolicy{},
equalIDMapTable: map[string][]*ForwardingPolicy{},
notEqualMapTable: map[string]map[string][]*ForwardingPolicy{},
notStarTable: map[string][]*ForwardingPolicy{},
defaultNotExistsPolicy: nil,
}
return m
} | go | func NewPolicyDB() (m *PolicyDB) {
m = &PolicyDB{
numberOfPolicies: 0,
equalPrefixes: map[string]intList{},
equalMapTable: map[string]map[string][]*ForwardingPolicy{},
equalIDMapTable: map[string][]*ForwardingPolicy{},
notEqualMapTable: map[string]map[string][]*ForwardingPolicy{},
notStarTable: map[string][]*ForwardingPolicy{},
defaultNotExistsPolicy: nil,
}
return m
} | [
"func",
"NewPolicyDB",
"(",
")",
"(",
"m",
"*",
"PolicyDB",
")",
"{",
"m",
"=",
"&",
"PolicyDB",
"{",
"numberOfPolicies",
":",
"0",
",",
"equalPrefixes",
":",
"map",
"[",
"string",
"]",
"intList",
"{",
"}",
",",
"equalMapTable",
":",
"map",
"[",
"str... | //NewPolicyDB creates a new PolicyDB for efficient search of policies | [
"NewPolicyDB",
"creates",
"a",
"new",
"PolicyDB",
"for",
"efficient",
"search",
"of",
"policies"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/lookup/lookup.go#L35-L48 |
6,859 | aporeto-inc/trireme-lib | controller/internal/enforcer/lookup/lookup.go | tagSplit | func (m *PolicyDB) tagSplit(tag string, k *string, v *string) error {
l := len(tag)
if l < 3 {
return fmt.Errorf("Invalid tag: invalid length '%s'", tag)
}
if tag[0] == '=' {
return fmt.Errorf("Invalid tag: missing key '%s'", tag)
}
for i := 0; i < l; i++ {
if tag[i] == '=' {
if i+1 >= l {
return fmt.Errorf("Invalid tag: missing value '%s'", tag)
}
*k = tag[:i]
*v = tag[i+1:]
return nil
}
}
return fmt.Errorf("Invalid tag: missing equal symbol '%s'", tag)
} | go | func (m *PolicyDB) tagSplit(tag string, k *string, v *string) error {
l := len(tag)
if l < 3 {
return fmt.Errorf("Invalid tag: invalid length '%s'", tag)
}
if tag[0] == '=' {
return fmt.Errorf("Invalid tag: missing key '%s'", tag)
}
for i := 0; i < l; i++ {
if tag[i] == '=' {
if i+1 >= l {
return fmt.Errorf("Invalid tag: missing value '%s'", tag)
}
*k = tag[:i]
*v = tag[i+1:]
return nil
}
}
return fmt.Errorf("Invalid tag: missing equal symbol '%s'", tag)
} | [
"func",
"(",
"m",
"*",
"PolicyDB",
")",
"tagSplit",
"(",
"tag",
"string",
",",
"k",
"*",
"string",
",",
"v",
"*",
"string",
")",
"error",
"{",
"l",
":=",
"len",
"(",
"tag",
")",
"\n",
"if",
"l",
"<",
"3",
"{",
"return",
"fmt",
".",
"Errorf",
... | // Custom implementation for splitting strings. Gives significant performance
// improvement. Do not allocate new strings | [
"Custom",
"implementation",
"for",
"splitting",
"strings",
".",
"Gives",
"significant",
"performance",
"improvement",
".",
"Do",
"not",
"allocate",
"new",
"strings"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/lookup/lookup.go#L151-L173 |
6,860 | aporeto-inc/trireme-lib | controller/internal/enforcer/lookup/lookup.go | Search | func (m *PolicyDB) Search(tags *policy.TagStore) (int, interface{}) {
count := make([]int, m.numberOfPolicies+1)
skip := make([]bool, m.numberOfPolicies+1)
// Disable all policies that fail the not key exists
copiedTags := tags.GetSlice()
var k, v string
for _, t := range copiedTags {
if err := m.tagSplit(t, &k, &v); err != nil {
continue
}
for _, policy := range m.notStarTable[k] {
skip[policy.index] = true
}
}
// Go through the list of tags
for _, t := range copiedTags {
// Search for matches of t (tag id)
if index, action := searchInMapTable(m.equalIDMapTable[t], count, skip); index >= 0 {
return index, action
}
if err := m.tagSplit(t, &k, &v); err != nil {
continue
}
// Search for matches of k=v
if index, action := searchInMapTable(m.equalMapTable[k][v], count, skip); index >= 0 {
return index, action
}
// Search for matches in prefixes
for _, i := range m.equalPrefixes[k] {
if i <= len(v) {
if index, action := searchInMapTable(m.equalMapTable[k][v[:i]], count, skip); index >= 0 {
return index, action
}
}
}
// Parse all of the policies that have a key that matches the incoming tag key
// and a not equal operator and that has a not match rule
for value, policies := range m.notEqualMapTable[k] {
if v == value {
continue
}
if index, action := searchInMapTable(policies, count, skip); index >= 0 {
return index, action
}
}
}
if m.defaultNotExistsPolicy != nil && !skip[m.defaultNotExistsPolicy.index] {
return m.defaultNotExistsPolicy.index, m.defaultNotExistsPolicy.actions
}
return -1, nil
} | go | func (m *PolicyDB) Search(tags *policy.TagStore) (int, interface{}) {
count := make([]int, m.numberOfPolicies+1)
skip := make([]bool, m.numberOfPolicies+1)
// Disable all policies that fail the not key exists
copiedTags := tags.GetSlice()
var k, v string
for _, t := range copiedTags {
if err := m.tagSplit(t, &k, &v); err != nil {
continue
}
for _, policy := range m.notStarTable[k] {
skip[policy.index] = true
}
}
// Go through the list of tags
for _, t := range copiedTags {
// Search for matches of t (tag id)
if index, action := searchInMapTable(m.equalIDMapTable[t], count, skip); index >= 0 {
return index, action
}
if err := m.tagSplit(t, &k, &v); err != nil {
continue
}
// Search for matches of k=v
if index, action := searchInMapTable(m.equalMapTable[k][v], count, skip); index >= 0 {
return index, action
}
// Search for matches in prefixes
for _, i := range m.equalPrefixes[k] {
if i <= len(v) {
if index, action := searchInMapTable(m.equalMapTable[k][v[:i]], count, skip); index >= 0 {
return index, action
}
}
}
// Parse all of the policies that have a key that matches the incoming tag key
// and a not equal operator and that has a not match rule
for value, policies := range m.notEqualMapTable[k] {
if v == value {
continue
}
if index, action := searchInMapTable(policies, count, skip); index >= 0 {
return index, action
}
}
}
if m.defaultNotExistsPolicy != nil && !skip[m.defaultNotExistsPolicy.index] {
return m.defaultNotExistsPolicy.index, m.defaultNotExistsPolicy.actions
}
return -1, nil
} | [
"func",
"(",
"m",
"*",
"PolicyDB",
")",
"Search",
"(",
"tags",
"*",
"policy",
".",
"TagStore",
")",
"(",
"int",
",",
"interface",
"{",
"}",
")",
"{",
"count",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"m",
".",
"numberOfPolicies",
"+",
"1",
")",
... | // Search searches for a set of tags in the database to find a policy match | [
"Search",
"searches",
"for",
"a",
"set",
"of",
"tags",
"in",
"the",
"database",
"to",
"find",
"a",
"policy",
"match"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/lookup/lookup.go#L176-L239 |
6,861 | aporeto-inc/trireme-lib | controller/internal/enforcer/lookup/lookup.go | PrintPolicyDB | func (m *PolicyDB) PrintPolicyDB() {
zap.L().Debug("Print Policy DB: equal table")
for key, values := range m.equalMapTable {
for value, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
zap.String("value", value),
)
}
}
zap.L().Debug("Print Policy DB: equal id table")
for key, values := range m.equalIDMapTable {
for _, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
)
}
}
zap.L().Debug("Print Policy DB - not equal table")
for key, values := range m.notEqualMapTable {
for value, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
zap.String("value", value),
)
}
}
} | go | func (m *PolicyDB) PrintPolicyDB() {
zap.L().Debug("Print Policy DB: equal table")
for key, values := range m.equalMapTable {
for value, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
zap.String("value", value),
)
}
}
zap.L().Debug("Print Policy DB: equal id table")
for key, values := range m.equalIDMapTable {
for _, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
)
}
}
zap.L().Debug("Print Policy DB - not equal table")
for key, values := range m.notEqualMapTable {
for value, policies := range values {
zap.L().Debug("Print Policy DB",
zap.String("policies", fmt.Sprintf("%#v", policies)),
zap.String("key", key),
zap.String("value", value),
)
}
}
} | [
"func",
"(",
"m",
"*",
"PolicyDB",
")",
"PrintPolicyDB",
"(",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"for",
"key",
",",
"values",
":=",
"range",
"m",
".",
"equalMapTable",
"{",
"for",
"value",
",",
"polic... | // PrintPolicyDB is a debugging function to dump the map | [
"PrintPolicyDB",
"is",
"a",
"debugging",
"function",
"to",
"dump",
"the",
"map"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/lookup/lookup.go#L263-L300 |
6,862 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | cgroupChainRules | func (i *Instance) cgroupChainRules(cfg *ACLInfo) [][]string {
// Rules for older distros (eg RH 6.9/Ubuntu 14.04), due to absence of
// cgroup match modules, source ports are used to trap outgoing traffic.
if i.isLegacyKernel && (cfg.PUType == common.HostNetworkPU || cfg.PUType == common.HostPU) {
return i.legacyPuChainRules(
cfg.ContextID,
cfg.AppChain,
cfg.NetChain,
cfg.CgroupMark,
cfg.TCPPorts,
cfg.UDPPorts,
cfg.ProxyPort,
cfg.ProxySetName,
cfg.AppSection,
cfg.NetSection,
cfg.PUType,
)
}
tmpl := template.Must(template.New(cgroupCaptureTemplate).Funcs(template.FuncMap{
"isUDPPorts": func() bool {
return cfg.UDPPorts != "0"
},
"isTCPPorts": func() bool {
return cfg.TCPPorts != "0"
},
"isHostPU": func() bool {
return cfg.AppSection == HostModeOutput && cfg.NetSection == HostModeInput
},
}).Parse(cgroupCaptureTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return append(rules, i.proxyRules(cfg)...)
} | go | func (i *Instance) cgroupChainRules(cfg *ACLInfo) [][]string {
// Rules for older distros (eg RH 6.9/Ubuntu 14.04), due to absence of
// cgroup match modules, source ports are used to trap outgoing traffic.
if i.isLegacyKernel && (cfg.PUType == common.HostNetworkPU || cfg.PUType == common.HostPU) {
return i.legacyPuChainRules(
cfg.ContextID,
cfg.AppChain,
cfg.NetChain,
cfg.CgroupMark,
cfg.TCPPorts,
cfg.UDPPorts,
cfg.ProxyPort,
cfg.ProxySetName,
cfg.AppSection,
cfg.NetSection,
cfg.PUType,
)
}
tmpl := template.Must(template.New(cgroupCaptureTemplate).Funcs(template.FuncMap{
"isUDPPorts": func() bool {
return cfg.UDPPorts != "0"
},
"isTCPPorts": func() bool {
return cfg.TCPPorts != "0"
},
"isHostPU": func() bool {
return cfg.AppSection == HostModeOutput && cfg.NetSection == HostModeInput
},
}).Parse(cgroupCaptureTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return append(rules, i.proxyRules(cfg)...)
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"cgroupChainRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"// Rules for older distros (eg RH 6.9/Ubuntu 14.04), due to absence of",
"// cgroup match modules, source ports are used to trap outgoing traffic.",... | // cgroupChainRules provides the rules for redirecting to a processing unit
// specific chain based for Linux processed and based on the cgroups and net_cls
// configuration. | [
"cgroupChainRules",
"provides",
"the",
"rules",
"for",
"redirecting",
"to",
"a",
"processing",
"unit",
"specific",
"chain",
"based",
"for",
"Linux",
"processed",
"and",
"based",
"on",
"the",
"cgroups",
"and",
"net_cls",
"configuration",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L39-L77 |
6,863 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | containerChainRules | func (i *Instance) containerChainRules(cfg *ACLInfo) [][]string {
tmpl := template.Must(template.New(containerChainTemplate).Parse(containerChainTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return append(rules, i.proxyRules(cfg)...)
} | go | func (i *Instance) containerChainRules(cfg *ACLInfo) [][]string {
tmpl := template.Must(template.New(containerChainTemplate).Parse(containerChainTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return append(rules, i.proxyRules(cfg)...)
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"containerChainRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"containerChainTemplate",
")",
".",
"Parse",
"("... | // containerChainRules provides the list of rules that are used to send traffic to
// a particular chain | [
"containerChainRules",
"provides",
"the",
"list",
"of",
"rules",
"that",
"are",
"used",
"to",
"send",
"traffic",
"to",
"a",
"particular",
"chain"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L96-L106 |
6,864 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | proxyRules | func (i *Instance) proxyRules(cfg *ACLInfo) [][]string {
tmpl := template.Must(template.New(proxyChainTemplate).Funcs(template.FuncMap{
"isCgroupSet": func() bool {
return cfg.CgroupMark != ""
},
}).Parse(proxyChainTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return rules
} | go | func (i *Instance) proxyRules(cfg *ACLInfo) [][]string {
tmpl := template.Must(template.New(proxyChainTemplate).Funcs(template.FuncMap{
"isCgroupSet": func() bool {
return cfg.CgroupMark != ""
},
}).Parse(proxyChainTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return rules
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"proxyRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"proxyChainTemplate",
")",
".",
"Funcs",
"(",
"template... | // proxyRules creates the rules that allow traffic to go through if it is handled
// by the services. | [
"proxyRules",
"creates",
"the",
"rules",
"that",
"allow",
"traffic",
"to",
"go",
"through",
"if",
"it",
"is",
"handled",
"by",
"the",
"services",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L110-L123 |
6,865 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | trapRules | func (i *Instance) trapRules(cfg *ACLInfo, isHostPU bool) [][]string {
tmpl := template.Must(template.New(packetCaptureTemplate).Funcs(template.FuncMap{
"needDnsRules": func() bool {
return i.mode == constants.Sidecar || isHostPU || i.isLegacyKernel
},
"isUIDProcess": func() bool {
return cfg.UID != ""
},
}).Parse(packetCaptureTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return rules
} | go | func (i *Instance) trapRules(cfg *ACLInfo, isHostPU bool) [][]string {
tmpl := template.Must(template.New(packetCaptureTemplate).Funcs(template.FuncMap{
"needDnsRules": func() bool {
return i.mode == constants.Sidecar || isHostPU || i.isLegacyKernel
},
"isUIDProcess": func() bool {
return cfg.UID != ""
},
}).Parse(packetCaptureTemplate))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
return rules
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"trapRules",
"(",
"cfg",
"*",
"ACLInfo",
",",
"isHostPU",
"bool",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"packetCaptureTemplate",
")",
"... | // trapRules provides the packet capture rules that are defined for each processing unit. | [
"trapRules",
"provides",
"the",
"packet",
"capture",
"rules",
"that",
"are",
"defined",
"for",
"each",
"processing",
"unit",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L126-L143 |
6,866 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | addContainerChain | func (i *Instance) addContainerChain(appChain string, netChain string) error {
if err := i.ipt.NewChain(i.appPacketIPTableContext, appChain); err != nil {
return fmt.Errorf("unable to add chain %s of context %s: %s", appChain, i.appPacketIPTableContext, err)
}
if err := i.ipt.NewChain(i.netPacketIPTableContext, netChain); err != nil {
return fmt.Errorf("unable to add netchain %s of context %s: %s", netChain, i.netPacketIPTableContext, err)
}
return nil
} | go | func (i *Instance) addContainerChain(appChain string, netChain string) error {
if err := i.ipt.NewChain(i.appPacketIPTableContext, appChain); err != nil {
return fmt.Errorf("unable to add chain %s of context %s: %s", appChain, i.appPacketIPTableContext, err)
}
if err := i.ipt.NewChain(i.netPacketIPTableContext, netChain); err != nil {
return fmt.Errorf("unable to add netchain %s of context %s: %s", netChain, i.netPacketIPTableContext, err)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"addContainerChain",
"(",
"appChain",
"string",
",",
"netChain",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"NewChain",
"(",
"i",
".",
"appPacketIPTableContext",
",",
"appChain",
")",
";"... | // addContainerChain adds a chain for the specific container and redirects traffic there
// This simplifies significantly the management and makes the iptable rules more readable
// All rules related to a container are contained within the dedicated chain | [
"addContainerChain",
"adds",
"a",
"chain",
"for",
"the",
"specific",
"container",
"and",
"redirects",
"traffic",
"there",
"This",
"simplifies",
"significantly",
"the",
"management",
"and",
"makes",
"the",
"iptable",
"rules",
"more",
"readable",
"All",
"rules",
"re... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L148-L159 |
6,867 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | processRulesFromList | func (i *Instance) processRulesFromList(rulelist [][]string, methodType string) error {
var err error
for _, cr := range rulelist {
// HACK: Adding a retry loop to avoid iptables error of "invalid argument"
// Once in a while iptables
L:
for retry := 0; retry < 3; retry++ {
switch methodType {
case "Append":
if err = i.ipt.Append(cr[0], cr[1], cr[2:]...); err == nil {
break L
}
case "Insert":
order, err := strconv.Atoi(cr[2])
if err != nil {
zap.L().Error("Incorrect format for iptables insert")
return errors.New("invalid format")
}
if err = i.ipt.Insert(cr[0], cr[1], order, cr[3:]...); err == nil {
break L
}
case "Delete":
if err = i.ipt.Delete(cr[0], cr[1], cr[2:]...); err == nil {
break L
}
default:
return errors.New("invalid method type")
}
}
if err != nil && methodType != "Delete" {
return fmt.Errorf("unable to %s rule for table %s and chain %s with error %s", methodType, cr[0], cr[1], err)
}
}
return nil
} | go | func (i *Instance) processRulesFromList(rulelist [][]string, methodType string) error {
var err error
for _, cr := range rulelist {
// HACK: Adding a retry loop to avoid iptables error of "invalid argument"
// Once in a while iptables
L:
for retry := 0; retry < 3; retry++ {
switch methodType {
case "Append":
if err = i.ipt.Append(cr[0], cr[1], cr[2:]...); err == nil {
break L
}
case "Insert":
order, err := strconv.Atoi(cr[2])
if err != nil {
zap.L().Error("Incorrect format for iptables insert")
return errors.New("invalid format")
}
if err = i.ipt.Insert(cr[0], cr[1], order, cr[3:]...); err == nil {
break L
}
case "Delete":
if err = i.ipt.Delete(cr[0], cr[1], cr[2:]...); err == nil {
break L
}
default:
return errors.New("invalid method type")
}
}
if err != nil && methodType != "Delete" {
return fmt.Errorf("unable to %s rule for table %s and chain %s with error %s", methodType, cr[0], cr[1], err)
}
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"processRulesFromList",
"(",
"rulelist",
"[",
"]",
"[",
"]",
"string",
",",
"methodType",
"string",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"for",
"_",
",",
"cr",
":=",
"range",
"rulelist",
"{",
"// HACK:... | // processRulesFromList is a generic helper that parses a set of rules and sends the corresponding
// ACL commands. | [
"processRulesFromList",
"is",
"a",
"generic",
"helper",
"that",
"parses",
"a",
"set",
"of",
"rules",
"and",
"sends",
"the",
"corresponding",
"ACL",
"commands",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L163-L200 |
6,868 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | addPacketTrap | func (i *Instance) addPacketTrap(cfg *ACLInfo, isHostPU bool) error {
return i.processRulesFromList(i.trapRules(cfg, isHostPU), "Append")
} | go | func (i *Instance) addPacketTrap(cfg *ACLInfo, isHostPU bool) error {
return i.processRulesFromList(i.trapRules(cfg, isHostPU), "Append")
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"addPacketTrap",
"(",
"cfg",
"*",
"ACLInfo",
",",
"isHostPU",
"bool",
")",
"error",
"{",
"return",
"i",
".",
"processRulesFromList",
"(",
"i",
".",
"trapRules",
"(",
"cfg",
",",
"isHostPU",
")",
",",
"\"",
"\"",
... | // addPacketTrap adds the necessary iptables rules to capture control packets to user space | [
"addPacketTrap",
"adds",
"the",
"necessary",
"iptables",
"rules",
"to",
"capture",
"control",
"packets",
"to",
"user",
"space"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L217-L220 |
6,869 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | programExtensionsRules | func (i *Instance) programExtensionsRules(rule *aclIPset, chain, proto, ipMatchDirection string) error {
rulesspec := []string{
"-p", proto,
"-m", "set", "--match-set", rule.ipset, ipMatchDirection,
"--match", "multiport", "--dports", strings.Join(rule.ports, ","),
}
for _, ext := range rule.extensions {
args, err := shellwords.Parse(ext)
if err != nil {
return fmt.Errorf("unable to parse extension %s: %v", ext, err)
}
rulesspec = append(rulesspec, args...)
if err := i.ipt.Append(i.appPacketIPTableContext, chain, rulesspec...); err != nil {
return fmt.Errorf("unable to program extension rules: %v", err)
}
}
return nil
} | go | func (i *Instance) programExtensionsRules(rule *aclIPset, chain, proto, ipMatchDirection string) error {
rulesspec := []string{
"-p", proto,
"-m", "set", "--match-set", rule.ipset, ipMatchDirection,
"--match", "multiport", "--dports", strings.Join(rule.ports, ","),
}
for _, ext := range rule.extensions {
args, err := shellwords.Parse(ext)
if err != nil {
return fmt.Errorf("unable to parse extension %s: %v", ext, err)
}
rulesspec = append(rulesspec, args...)
if err := i.ipt.Append(i.appPacketIPTableContext, chain, rulesspec...); err != nil {
return fmt.Errorf("unable to program extension rules: %v", err)
}
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"programExtensionsRules",
"(",
"rule",
"*",
"aclIPset",
",",
"chain",
",",
"proto",
",",
"ipMatchDirection",
"string",
")",
"error",
"{",
"rulesspec",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"proto",
",",
... | // programExtensionsRules programs iptable rules for the given extensions | [
"programExtensionsRules",
"programs",
"iptable",
"rules",
"for",
"the",
"given",
"extensions"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L298-L320 |
6,870 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | sortACLsInBuckets | func (i *Instance) sortACLsInBuckets(contextID, chain string, reverseChain string, rules []aclIPset, isAppACLs bool) *rulesInfo {
rulesBucket := &rulesInfo{
RejectObserveApply: [][]string{},
RejectNotObserved: [][]string{},
RejectObserveContinue: [][]string{},
AcceptObserveApply: [][]string{},
AcceptNotObserved: [][]string{},
AcceptObserveContinue: [][]string{},
ReverseRules: [][]string{},
}
direction := "src"
reverse := "dst"
nflogGroup := "11"
if isAppACLs {
direction = "dst"
reverse = "src"
nflogGroup = "10"
}
for _, rule := range rules {
for _, proto := range rule.protocols {
acls, r := i.generateACLRules(contextID, &rule, chain, reverseChain, nflogGroup, proto, direction, reverse)
rulesBucket.ReverseRules = append(rulesBucket.ReverseRules, r...)
if testReject(rule.policy) && testObserveApply(rule.policy) {
rulesBucket.RejectObserveApply = append(rulesBucket.RejectObserveApply, acls...)
}
if testReject(rule.policy) && testNotObserved(rule.policy) {
rulesBucket.RejectNotObserved = append(rulesBucket.RejectNotObserved, acls...)
}
if testReject(rule.policy) && testObserveContinue(rule.policy) {
rulesBucket.RejectObserveContinue = append(rulesBucket.RejectObserveContinue, acls...)
}
if testAccept(rule.policy) && testObserveContinue(rule.policy) {
rulesBucket.AcceptObserveContinue = append(rulesBucket.AcceptObserveContinue, acls...)
}
if testAccept(rule.policy) && testNotObserved(rule.policy) {
rulesBucket.AcceptNotObserved = append(rulesBucket.AcceptNotObserved, acls...)
}
if testAccept(rule.policy) && testObserveApply(rule.policy) {
rulesBucket.AcceptObserveApply = append(rulesBucket.AcceptObserveApply, acls...)
}
}
}
return rulesBucket
} | go | func (i *Instance) sortACLsInBuckets(contextID, chain string, reverseChain string, rules []aclIPset, isAppACLs bool) *rulesInfo {
rulesBucket := &rulesInfo{
RejectObserveApply: [][]string{},
RejectNotObserved: [][]string{},
RejectObserveContinue: [][]string{},
AcceptObserveApply: [][]string{},
AcceptNotObserved: [][]string{},
AcceptObserveContinue: [][]string{},
ReverseRules: [][]string{},
}
direction := "src"
reverse := "dst"
nflogGroup := "11"
if isAppACLs {
direction = "dst"
reverse = "src"
nflogGroup = "10"
}
for _, rule := range rules {
for _, proto := range rule.protocols {
acls, r := i.generateACLRules(contextID, &rule, chain, reverseChain, nflogGroup, proto, direction, reverse)
rulesBucket.ReverseRules = append(rulesBucket.ReverseRules, r...)
if testReject(rule.policy) && testObserveApply(rule.policy) {
rulesBucket.RejectObserveApply = append(rulesBucket.RejectObserveApply, acls...)
}
if testReject(rule.policy) && testNotObserved(rule.policy) {
rulesBucket.RejectNotObserved = append(rulesBucket.RejectNotObserved, acls...)
}
if testReject(rule.policy) && testObserveContinue(rule.policy) {
rulesBucket.RejectObserveContinue = append(rulesBucket.RejectObserveContinue, acls...)
}
if testAccept(rule.policy) && testObserveContinue(rule.policy) {
rulesBucket.AcceptObserveContinue = append(rulesBucket.AcceptObserveContinue, acls...)
}
if testAccept(rule.policy) && testNotObserved(rule.policy) {
rulesBucket.AcceptNotObserved = append(rulesBucket.AcceptNotObserved, acls...)
}
if testAccept(rule.policy) && testObserveApply(rule.policy) {
rulesBucket.AcceptObserveApply = append(rulesBucket.AcceptObserveApply, acls...)
}
}
}
return rulesBucket
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"sortACLsInBuckets",
"(",
"contextID",
",",
"chain",
"string",
",",
"reverseChain",
"string",
",",
"rules",
"[",
"]",
"aclIPset",
",",
"isAppACLs",
"bool",
")",
"*",
"rulesInfo",
"{",
"rulesBucket",
":=",
"&",
"rules... | // sortACLsInBuckets will process all the rules and add them in a list of buckets
// based on their priority. We need an explicit order of these buckets
// in order to support observation only of ACL actions. The parameters
// must provide the chain and whether it is App or Net ACLs so that the rules
// can be created accordingly. | [
"sortACLsInBuckets",
"will",
"process",
"all",
"the",
"rules",
"and",
"add",
"them",
"in",
"a",
"list",
"of",
"buckets",
"based",
"on",
"their",
"priority",
".",
"We",
"need",
"an",
"explicit",
"order",
"of",
"these",
"buckets",
"in",
"order",
"to",
"suppo... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L327-L382 |
6,871 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | addExternalACLs | func (i *Instance) addExternalACLs(contextID string, chain string, reverseChain string, rules []aclIPset, isAppAcls bool) error {
rulesBucket := i.sortACLsInBuckets(contextID, chain, reverseChain, rules, isAppAcls)
tmpl := template.Must(template.New(acls).Funcs(template.FuncMap{
"joinRule": func(rule []string) string {
return strings.Join(rule, " ")
},
}).Parse(acls))
aclRules, err := extractRulesFromTemplate(tmpl, *rulesBucket)
if err != nil {
return fmt.Errorf("unable to extract rules from template: %s", err)
}
if err := i.processRulesFromList(aclRules, "Append"); err != nil {
return fmt.Errorf("unable to install rules - mode :%s %v", err, isAppAcls)
}
return nil
} | go | func (i *Instance) addExternalACLs(contextID string, chain string, reverseChain string, rules []aclIPset, isAppAcls bool) error {
rulesBucket := i.sortACLsInBuckets(contextID, chain, reverseChain, rules, isAppAcls)
tmpl := template.Must(template.New(acls).Funcs(template.FuncMap{
"joinRule": func(rule []string) string {
return strings.Join(rule, " ")
},
}).Parse(acls))
aclRules, err := extractRulesFromTemplate(tmpl, *rulesBucket)
if err != nil {
return fmt.Errorf("unable to extract rules from template: %s", err)
}
if err := i.processRulesFromList(aclRules, "Append"); err != nil {
return fmt.Errorf("unable to install rules - mode :%s %v", err, isAppAcls)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"addExternalACLs",
"(",
"contextID",
"string",
",",
"chain",
"string",
",",
"reverseChain",
"string",
",",
"rules",
"[",
"]",
"aclIPset",
",",
"isAppAcls",
"bool",
")",
"error",
"{",
"rulesBucket",
":=",
"i",
".",
... | // addExternalACLs adds a set of rules to the external services that are initiated
// by an application. The allow rules are inserted with highest priority. | [
"addExternalACLs",
"adds",
"a",
"set",
"of",
"rules",
"to",
"the",
"external",
"services",
"that",
"are",
"initiated",
"by",
"an",
"application",
".",
"The",
"allow",
"rules",
"are",
"inserted",
"with",
"highest",
"priority",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L386-L406 |
6,872 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | deleteChainRules | func (i *Instance) deleteChainRules(cfg *ACLInfo) error {
if i.mode != constants.LocalServer {
return i.processRulesFromList(i.containerChainRules(cfg), "Delete")
}
if cfg.UID != "" {
return i.processRulesFromList(i.uidChainRules(cfg), "Delete")
}
return i.processRulesFromList(i.cgroupChainRules(cfg), "Delete")
} | go | func (i *Instance) deleteChainRules(cfg *ACLInfo) error {
if i.mode != constants.LocalServer {
return i.processRulesFromList(i.containerChainRules(cfg), "Delete")
}
if cfg.UID != "" {
return i.processRulesFromList(i.uidChainRules(cfg), "Delete")
}
return i.processRulesFromList(i.cgroupChainRules(cfg), "Delete")
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"deleteChainRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"error",
"{",
"if",
"i",
".",
"mode",
"!=",
"constants",
".",
"LocalServer",
"{",
"return",
"i",
".",
"processRulesFromList",
"(",
"i",
".",
"containerChainRules",... | // deleteChainRules deletes the rules that send traffic to our chain | [
"deleteChainRules",
"deletes",
"the",
"rules",
"that",
"send",
"traffic",
"to",
"our",
"chain"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L409-L420 |
6,873 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | deletePUChains | func (i *Instance) deletePUChains(appChain, netChain string) error {
if err := i.ipt.ClearChain(i.appPacketIPTableContext, appChain); err != nil {
zap.L().Warn("Failed to clear the container ack packets chain",
zap.String("appChain", appChain),
zap.String("context", i.appPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(i.appPacketIPTableContext, appChain); err != nil {
zap.L().Warn("Failed to delete the container ack packets chain",
zap.String("appChain", appChain),
zap.String("context", i.appPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.ClearChain(i.netPacketIPTableContext, netChain); err != nil {
zap.L().Warn("Failed to clear the container net packets chain",
zap.String("netChain", netChain),
zap.String("context", i.netPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(i.netPacketIPTableContext, netChain); err != nil {
zap.L().Warn("Failed to delete the container net packets chain",
zap.String("netChain", netChain),
zap.String("context", i.netPacketIPTableContext),
zap.Error(err),
)
}
return nil
} | go | func (i *Instance) deletePUChains(appChain, netChain string) error {
if err := i.ipt.ClearChain(i.appPacketIPTableContext, appChain); err != nil {
zap.L().Warn("Failed to clear the container ack packets chain",
zap.String("appChain", appChain),
zap.String("context", i.appPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(i.appPacketIPTableContext, appChain); err != nil {
zap.L().Warn("Failed to delete the container ack packets chain",
zap.String("appChain", appChain),
zap.String("context", i.appPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.ClearChain(i.netPacketIPTableContext, netChain); err != nil {
zap.L().Warn("Failed to clear the container net packets chain",
zap.String("netChain", netChain),
zap.String("context", i.netPacketIPTableContext),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(i.netPacketIPTableContext, netChain); err != nil {
zap.L().Warn("Failed to delete the container net packets chain",
zap.String("netChain", netChain),
zap.String("context", i.netPacketIPTableContext),
zap.Error(err),
)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"deletePUChains",
"(",
"appChain",
",",
"netChain",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"ClearChain",
"(",
"i",
".",
"appPacketIPTableContext",
",",
"appChain",
")",
";",
"err",
... | // deletePUChains removes all the container specific chains and basic rules | [
"deletePUChains",
"removes",
"all",
"the",
"container",
"specific",
"chains",
"and",
"basic",
"rules"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L423-L458 |
6,874 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | setGlobalRules | func (i *Instance) setGlobalRules() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(globalRules).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(globalRules))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
if err := i.processRulesFromList(rules, "Append"); err != nil {
return fmt.Errorf("unable to install global rules:%s", err)
}
// nat rules cannot be templated, since they interfere with Docker.
err = i.ipt.Insert(i.appProxyIPTableContext,
ipTableSectionPreRouting, 1,
"-p", "tcp",
"-m", "addrtype", "--dst-type", "LOCAL",
"-m", "set", "!", "--match-set", excludedNetworkSet, "src",
"-j", natProxyInputChain)
if err != nil {
return fmt.Errorf("unable to add default allow for marked packets at net: %s", err)
}
err = i.ipt.Insert(i.appProxyIPTableContext,
ipTableSectionOutput, 1,
"-m", "set", "!", "--match-set", excludedNetworkSet, "dst",
"-j", natProxyOutputChain)
if err != nil {
return fmt.Errorf("unable to add default allow for marked packets at net: %s", err)
}
return nil
} | go | func (i *Instance) setGlobalRules() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(globalRules).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(globalRules))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
zap.L().Warn("unable to extract rules", zap.Error(err))
}
if err := i.processRulesFromList(rules, "Append"); err != nil {
return fmt.Errorf("unable to install global rules:%s", err)
}
// nat rules cannot be templated, since they interfere with Docker.
err = i.ipt.Insert(i.appProxyIPTableContext,
ipTableSectionPreRouting, 1,
"-p", "tcp",
"-m", "addrtype", "--dst-type", "LOCAL",
"-m", "set", "!", "--match-set", excludedNetworkSet, "src",
"-j", natProxyInputChain)
if err != nil {
return fmt.Errorf("unable to add default allow for marked packets at net: %s", err)
}
err = i.ipt.Insert(i.appProxyIPTableContext,
ipTableSectionOutput, 1,
"-m", "set", "!", "--match-set", excludedNetworkSet, "dst",
"-j", natProxyOutputChain)
if err != nil {
return fmt.Errorf("unable to add default allow for marked packets at net: %s", err)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"setGlobalRules",
"(",
")",
"error",
"{",
"cfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"0",
",",
"\"",
"\"",
",",
"nil",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",... | // setGlobalRules installs the global rules | [
"setGlobalRules",
"installs",
"the",
"global",
"rules"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L461-L503 |
6,875 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/acls.go | cleanACLSection | func (i *Instance) cleanACLSection(context, chainPrefix string) {
rules, err := i.ipt.ListChains(context)
if err != nil {
zap.L().Warn("Failed to list chains",
zap.String("context", context),
zap.Error(err),
)
}
for _, rule := range rules {
if strings.Contains(rule, chainPrefix) {
if err := i.ipt.ClearChain(context, rule); err != nil {
zap.L().Warn("Can not clear the chain",
zap.String("context", context),
zap.String("section", rule),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(context, rule); err != nil {
zap.L().Warn("Can not delete the chain",
zap.String("context", context),
zap.String("section", rule),
zap.Error(err),
)
}
}
}
} | go | func (i *Instance) cleanACLSection(context, chainPrefix string) {
rules, err := i.ipt.ListChains(context)
if err != nil {
zap.L().Warn("Failed to list chains",
zap.String("context", context),
zap.Error(err),
)
}
for _, rule := range rules {
if strings.Contains(rule, chainPrefix) {
if err := i.ipt.ClearChain(context, rule); err != nil {
zap.L().Warn("Can not clear the chain",
zap.String("context", context),
zap.String("section", rule),
zap.Error(err),
)
}
if err := i.ipt.DeleteChain(context, rule); err != nil {
zap.L().Warn("Can not delete the chain",
zap.String("context", context),
zap.String("section", rule),
zap.Error(err),
)
}
}
}
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"cleanACLSection",
"(",
"context",
",",
"chainPrefix",
"string",
")",
"{",
"rules",
",",
"err",
":=",
"i",
".",
"ipt",
".",
"ListChains",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
... | // cleanACLSection flushes and deletes all chains with Prefix - Trireme | [
"cleanACLSection",
"flushes",
"and",
"deletes",
"all",
"chains",
"with",
"Prefix",
"-",
"Trireme"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/acls.go#L574-L603 |
6,876 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | NewMockRuntimeReader | func NewMockRuntimeReader(ctrl *gomock.Controller) *MockRuntimeReader {
mock := &MockRuntimeReader{ctrl: ctrl}
mock.recorder = &MockRuntimeReaderMockRecorder{mock}
return mock
} | go | func NewMockRuntimeReader(ctrl *gomock.Controller) *MockRuntimeReader {
mock := &MockRuntimeReader{ctrl: ctrl}
mock.recorder = &MockRuntimeReaderMockRecorder{mock}
return mock
} | [
"func",
"NewMockRuntimeReader",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRuntimeReader",
"{",
"mock",
":=",
"&",
"MockRuntimeReader",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRuntimeReaderMockRecorder",
... | // NewMockRuntimeReader creates a new mock instance
// nolint | [
"NewMockRuntimeReader",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L32-L36 |
6,877 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | Pid | func (m *MockRuntimeReader) Pid() int {
ret := m.ctrl.Call(m, "Pid")
ret0, _ := ret[0].(int)
return ret0
} | go | func (m *MockRuntimeReader) Pid() int {
ret := m.ctrl.Call(m, "Pid")
ret0, _ := ret[0].(int)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"Pid",
"(",
")",
"int",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"int",
")",
"\n",
"retur... | // Pid mocks base method
// nolint | [
"Pid",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L46-L50 |
6,878 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | Tag | func (m *MockRuntimeReader) Tag(arg0 string) (string, bool) {
ret := m.ctrl.Call(m, "Tag", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | func (m *MockRuntimeReader) Tag(arg0 string) (string, bool) {
ret := m.ctrl.Call(m, "Tag", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"Tag",
"(",
"arg0",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"... | // Tag mocks base method
// nolint | [
"Tag",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L88-L93 |
6,879 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | Tag | func (mr *MockRuntimeReaderMockRecorder) Tag(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRuntimeReader)(nil).Tag), arg0)
} | go | func (mr *MockRuntimeReaderMockRecorder) Tag(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockRuntimeReader)(nil).Tag), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockRuntimeReaderMockRecorder",
")",
"Tag",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
... | // Tag indicates an expected call of Tag
// nolint | [
"Tag",
"indicates",
"an",
"expected",
"call",
"of",
"Tag",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L97-L99 |
6,880 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | Tags | func (m *MockRuntimeReader) Tags() *policy.TagStore {
ret := m.ctrl.Call(m, "Tags")
ret0, _ := ret[0].(*policy.TagStore)
return ret0
} | go | func (m *MockRuntimeReader) Tags() *policy.TagStore {
ret := m.ctrl.Call(m, "Tags")
ret0, _ := ret[0].(*policy.TagStore)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"Tags",
"(",
")",
"*",
"policy",
".",
"TagStore",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
... | // Tags mocks base method
// nolint | [
"Tags",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L103-L107 |
6,881 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | Options | func (m *MockRuntimeReader) Options() policy.OptionsType {
ret := m.ctrl.Call(m, "Options")
ret0, _ := ret[0].(policy.OptionsType)
return ret0
} | go | func (m *MockRuntimeReader) Options() policy.OptionsType {
ret := m.ctrl.Call(m, "Options")
ret0, _ := ret[0].(policy.OptionsType)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"Options",
"(",
")",
"policy",
".",
"OptionsType",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
... | // Options mocks base method
// nolint | [
"Options",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L117-L121 |
6,882 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | IPAddresses | func (m *MockRuntimeReader) IPAddresses() policy.ExtendedMap {
ret := m.ctrl.Call(m, "IPAddresses")
ret0, _ := ret[0].(policy.ExtendedMap)
return ret0
} | go | func (m *MockRuntimeReader) IPAddresses() policy.ExtendedMap {
ret := m.ctrl.Call(m, "IPAddresses")
ret0, _ := ret[0].(policy.ExtendedMap)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"IPAddresses",
"(",
")",
"policy",
".",
"ExtendedMap",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(... | // IPAddresses mocks base method
// nolint | [
"IPAddresses",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L131-L135 |
6,883 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | PUType | func (m *MockRuntimeReader) PUType() common.PUType {
ret := m.ctrl.Call(m, "PUType")
ret0, _ := ret[0].(common.PUType)
return ret0
} | go | func (m *MockRuntimeReader) PUType() common.PUType {
ret := m.ctrl.Call(m, "PUType")
ret0, _ := ret[0].(common.PUType)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"PUType",
"(",
")",
"common",
".",
"PUType",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"comm... | // PUType mocks base method
// nolint | [
"PUType",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L145-L149 |
6,884 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | PUType | func (mr *MockRuntimeReaderMockRecorder) PUType() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PUType", reflect.TypeOf((*MockRuntimeReader)(nil).PUType))
} | go | func (mr *MockRuntimeReaderMockRecorder) PUType() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PUType", reflect.TypeOf((*MockRuntimeReader)(nil).PUType))
} | [
"func",
"(",
"mr",
"*",
"MockRuntimeReaderMockRecorder",
")",
"PUType",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
... | // PUType indicates an expected call of PUType
// nolint | [
"PUType",
"indicates",
"an",
"expected",
"call",
"of",
"PUType",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L153-L155 |
6,885 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | SetServices | func (m *MockRuntimeReader) SetServices(services []common.Service) {
m.ctrl.Call(m, "SetServices", services)
} | go | func (m *MockRuntimeReader) SetServices(services []common.Service) {
m.ctrl.Call(m, "SetServices", services)
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"SetServices",
"(",
"services",
"[",
"]",
"common",
".",
"Service",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"services",
")",
"\n",
"}"
] | // SetServices mocks base method
// nolint | [
"SetServices",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L159-L161 |
6,886 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | SetServices | func (mr *MockRuntimeReaderMockRecorder) SetServices(services interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetServices", reflect.TypeOf((*MockRuntimeReader)(nil).SetServices), services)
} | go | func (mr *MockRuntimeReaderMockRecorder) SetServices(services interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetServices", reflect.TypeOf((*MockRuntimeReader)(nil).SetServices), services)
} | [
"func",
"(",
"mr",
"*",
"MockRuntimeReaderMockRecorder",
")",
"SetServices",
"(",
"services",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",... | // SetServices indicates an expected call of SetServices
// nolint | [
"SetServices",
"indicates",
"an",
"expected",
"call",
"of",
"SetServices",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L165-L167 |
6,887 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | PortMap | func (m *MockRuntimeReader) PortMap() map[nat.Port][]string {
ret := m.ctrl.Call(m, "PortMap")
ret0, _ := ret[0].(map[nat.Port][]string)
return ret0
} | go | func (m *MockRuntimeReader) PortMap() map[nat.Port][]string {
ret := m.ctrl.Call(m, "PortMap")
ret0, _ := ret[0].(map[nat.Port][]string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRuntimeReader",
")",
"PortMap",
"(",
")",
"map",
"[",
"nat",
".",
"Port",
"]",
"[",
"]",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret... | // PortMap mocks base method
// nolint | [
"PortMap",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L171-L175 |
6,888 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | NewMockResolver | func NewMockResolver(ctrl *gomock.Controller) *MockResolver {
mock := &MockResolver{ctrl: ctrl}
mock.recorder = &MockResolverMockRecorder{mock}
return mock
} | go | func NewMockResolver(ctrl *gomock.Controller) *MockResolver {
mock := &MockResolver{ctrl: ctrl}
mock.recorder = &MockResolverMockRecorder{mock}
return mock
} | [
"func",
"NewMockResolver",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockResolver",
"{",
"mock",
":=",
"&",
"MockResolver",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockResolverMockRecorder",
"{",
"mock",
"}"... | // NewMockResolver creates a new mock instance
// nolint | [
"NewMockResolver",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L198-L202 |
6,889 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | HandlePUEvent | func (m *MockResolver) HandlePUEvent(ctx context.Context, puID string, event common.Event, runtime policy.RuntimeReader) error {
ret := m.ctrl.Call(m, "HandlePUEvent", ctx, puID, event, runtime)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockResolver) HandlePUEvent(ctx context.Context, puID string, event common.Event, runtime policy.RuntimeReader) error {
ret := m.ctrl.Call(m, "HandlePUEvent", ctx, puID, event, runtime)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockResolver",
")",
"HandlePUEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"puID",
"string",
",",
"event",
"common",
".",
"Event",
",",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"... | // HandlePUEvent mocks base method
// nolint | [
"HandlePUEvent",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L212-L216 |
6,890 | aporeto-inc/trireme-lib | policy/mockpolicy/mockpolicy.go | HandlePUEvent | func (mr *MockResolverMockRecorder) HandlePUEvent(ctx, puID, event, runtime interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePUEvent", reflect.TypeOf((*MockResolver)(nil).HandlePUEvent), ctx, puID, event, runtime)
} | go | func (mr *MockResolverMockRecorder) HandlePUEvent(ctx, puID, event, runtime interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePUEvent", reflect.TypeOf((*MockResolver)(nil).HandlePUEvent), ctx, puID, event, runtime)
} | [
"func",
"(",
"mr",
"*",
"MockResolverMockRecorder",
")",
"HandlePUEvent",
"(",
"ctx",
",",
"puID",
",",
"event",
",",
"runtime",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMe... | // HandlePUEvent indicates an expected call of HandlePUEvent
// nolint | [
"HandlePUEvent",
"indicates",
"an",
"expected",
"call",
"of",
"HandlePUEvent",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/mockpolicy/mockpolicy.go#L220-L222 |
6,891 | aporeto-inc/trireme-lib | controller/pkg/tokens/errors.go | Code | func (e *ErrToken) Code() string {
switch e.message {
case errCompressedTagMismatch:
return collector.CompressedTagMismatch
case errDatapathVersionMismatch:
return collector.DatapathVersionMismatch
default:
return collector.InvalidToken
}
} | go | func (e *ErrToken) Code() string {
switch e.message {
case errCompressedTagMismatch:
return collector.CompressedTagMismatch
case errDatapathVersionMismatch:
return collector.DatapathVersionMismatch
default:
return collector.InvalidToken
}
} | [
"func",
"(",
"e",
"*",
"ErrToken",
")",
"Code",
"(",
")",
"string",
"{",
"switch",
"e",
".",
"message",
"{",
"case",
"errCompressedTagMismatch",
":",
"return",
"collector",
".",
"CompressedTagMismatch",
"\n",
"case",
"errDatapathVersionMismatch",
":",
"return",
... | // Code returns collector reason | [
"Code",
"returns",
"collector",
"reason"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/errors.go#L29-L39 |
6,892 | aporeto-inc/trireme-lib | controller/pkg/tokens/errors.go | CodeFromErr | func CodeFromErr(err error) string {
errToken, ok := err.(*ErrToken)
if !ok {
return collector.InvalidToken
}
return errToken.Code()
} | go | func CodeFromErr(err error) string {
errToken, ok := err.(*ErrToken)
if !ok {
return collector.InvalidToken
}
return errToken.Code()
} | [
"func",
"CodeFromErr",
"(",
"err",
"error",
")",
"string",
"{",
"errToken",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"ErrToken",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"collector",
".",
"InvalidToken",
"\n",
"}",
"\n\n",
"return",
"errToken",
".",
... | // CodeFromErr returns the collector code from ErrToken | [
"CodeFromErr",
"returns",
"the",
"collector",
"code",
"from",
"ErrToken"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/errors.go#L42-L50 |
6,893 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/nflog/nflog_linux.go | Run | func (a *nfLog) Run(ctx context.Context) {
a.Lock()
a.srcNflogHandle, _ = nflog.BindAndListenForLogs([]uint16{a.ipv4groupSource}, 64, a.sourceNFLogsHanlder, a.nflogErrorHandler)
a.dstNflogHandle, _ = nflog.BindAndListenForLogs([]uint16{a.ipv4groupDest}, 64, a.destNFLogsHandler, a.nflogErrorHandler)
a.Unlock()
go func() {
<-ctx.Done()
a.Lock()
a.srcNflogHandle.NFlogClose()
a.dstNflogHandle.NFlogClose()
a.Unlock()
}()
} | go | func (a *nfLog) Run(ctx context.Context) {
a.Lock()
a.srcNflogHandle, _ = nflog.BindAndListenForLogs([]uint16{a.ipv4groupSource}, 64, a.sourceNFLogsHanlder, a.nflogErrorHandler)
a.dstNflogHandle, _ = nflog.BindAndListenForLogs([]uint16{a.ipv4groupDest}, 64, a.destNFLogsHandler, a.nflogErrorHandler)
a.Unlock()
go func() {
<-ctx.Done()
a.Lock()
a.srcNflogHandle.NFlogClose()
a.dstNflogHandle.NFlogClose()
a.Unlock()
}()
} | [
"func",
"(",
"a",
"*",
"nfLog",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"a",
".",
"Lock",
"(",
")",
"\n",
"a",
".",
"srcNflogHandle",
",",
"_",
"=",
"nflog",
".",
"BindAndListenForLogs",
"(",
"[",
"]",
"uint16",
"{",
"a",
"."... | // Run runs the Nf Logger | [
"Run",
"runs",
"the",
"Nf",
"Logger"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/nflog/nflog_linux.go#L40-L54 |
6,894 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/state.go | newAppConnectionState | func newAppConnectionState(nativeID, serviceID string, p *pucontext.PUContext, r *http.Request, originalDestination *net.TCPAddr) *connectionState {
sourceIP := "0.0.0.0/0"
sourcePort := 0
if sourceAddress, err := net.ResolveTCPAddr("tcp", r.RemoteAddr); err == nil {
sourceIP = sourceAddress.IP.String()
sourcePort = sourceAddress.Port
}
return &connectionState{
stats: &collector.FlowRecord{
ContextID: nativeID,
Destination: &collector.EndPoint{
URI: r.Method + " " + r.RequestURI,
HTTPMethod: r.Method,
Type: collector.EndPointTypeExternalIP,
Port: uint16(originalDestination.Port),
IP: originalDestination.IP.String(),
ID: collector.DefaultEndPoint,
},
Source: &collector.EndPoint{
Type: collector.EnpointTypePU,
ID: p.ManagementID(),
IP: sourceIP,
Port: uint16(sourcePort),
HTTPMethod: r.Method,
URI: r.Method + " " + r.RequestURI,
},
Action: policy.Reject,
L4Protocol: packet.IPProtocolTCP,
ServiceType: policy.ServiceHTTP,
ServiceID: serviceID,
Tags: p.Annotations(),
PolicyID: "default",
Count: 1,
},
}
} | go | func newAppConnectionState(nativeID, serviceID string, p *pucontext.PUContext, r *http.Request, originalDestination *net.TCPAddr) *connectionState {
sourceIP := "0.0.0.0/0"
sourcePort := 0
if sourceAddress, err := net.ResolveTCPAddr("tcp", r.RemoteAddr); err == nil {
sourceIP = sourceAddress.IP.String()
sourcePort = sourceAddress.Port
}
return &connectionState{
stats: &collector.FlowRecord{
ContextID: nativeID,
Destination: &collector.EndPoint{
URI: r.Method + " " + r.RequestURI,
HTTPMethod: r.Method,
Type: collector.EndPointTypeExternalIP,
Port: uint16(originalDestination.Port),
IP: originalDestination.IP.String(),
ID: collector.DefaultEndPoint,
},
Source: &collector.EndPoint{
Type: collector.EnpointTypePU,
ID: p.ManagementID(),
IP: sourceIP,
Port: uint16(sourcePort),
HTTPMethod: r.Method,
URI: r.Method + " " + r.RequestURI,
},
Action: policy.Reject,
L4Protocol: packet.IPProtocolTCP,
ServiceType: policy.ServiceHTTP,
ServiceID: serviceID,
Tags: p.Annotations(),
PolicyID: "default",
Count: 1,
},
}
} | [
"func",
"newAppConnectionState",
"(",
"nativeID",
",",
"serviceID",
"string",
",",
"p",
"*",
"pucontext",
".",
"PUContext",
",",
"r",
"*",
"http",
".",
"Request",
",",
"originalDestination",
"*",
"net",
".",
"TCPAddr",
")",
"*",
"connectionState",
"{",
"sour... | // newAppConnectionState will create the initial connection state object. | [
"newAppConnectionState",
"will",
"create",
"the",
"initial",
"connection",
"state",
"object",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/state.go#L22-L59 |
6,895 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/state.go | newNetworkConnectionState | func newNetworkConnectionState(nativeID string, pctx *serviceregistry.PortContext, r *http.Request, source, dest *net.TCPAddr) *connectionState {
return &connectionState{
stats: &collector.FlowRecord{
ContextID: nativeID,
Destination: &collector.EndPoint{
ID: pctx.PUContext.ManagementID(),
URI: r.Method + " " + r.RequestURI,
HTTPMethod: r.Method,
Type: collector.EnpointTypePU,
IP: dest.IP.String(),
Port: uint16(dest.Port),
},
Source: &collector.EndPoint{
Type: collector.EndPointTypeExternalIP,
IP: source.IP.String(),
ID: collector.DefaultEndPoint,
Port: uint16(source.Port),
},
Action: policy.Reject,
L4Protocol: packet.IPProtocolTCP,
ServiceType: policy.ServiceHTTP,
PolicyID: "default",
ServiceID: pctx.Service.ID,
Tags: pctx.PUContext.Annotations(),
Count: 1,
},
}
} | go | func newNetworkConnectionState(nativeID string, pctx *serviceregistry.PortContext, r *http.Request, source, dest *net.TCPAddr) *connectionState {
return &connectionState{
stats: &collector.FlowRecord{
ContextID: nativeID,
Destination: &collector.EndPoint{
ID: pctx.PUContext.ManagementID(),
URI: r.Method + " " + r.RequestURI,
HTTPMethod: r.Method,
Type: collector.EnpointTypePU,
IP: dest.IP.String(),
Port: uint16(dest.Port),
},
Source: &collector.EndPoint{
Type: collector.EndPointTypeExternalIP,
IP: source.IP.String(),
ID: collector.DefaultEndPoint,
Port: uint16(source.Port),
},
Action: policy.Reject,
L4Protocol: packet.IPProtocolTCP,
ServiceType: policy.ServiceHTTP,
PolicyID: "default",
ServiceID: pctx.Service.ID,
Tags: pctx.PUContext.Annotations(),
Count: 1,
},
}
} | [
"func",
"newNetworkConnectionState",
"(",
"nativeID",
"string",
",",
"pctx",
"*",
"serviceregistry",
".",
"PortContext",
",",
"r",
"*",
"http",
".",
"Request",
",",
"source",
",",
"dest",
"*",
"net",
".",
"TCPAddr",
")",
"*",
"connectionState",
"{",
"return"... | // newNetworkConnectionState will create the initial connection state object. | [
"newNetworkConnectionState",
"will",
"create",
"the",
"initial",
"connection",
"state",
"object",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/state.go#L62-L89 |
6,896 | aporeto-inc/trireme-lib | monitor/internal/cni/extractor.go | KubernetesMetadataExtractor | func KubernetesMetadataExtractor(event *common.EventInfo) (*policy.PURuntime, error) {
if event.NS == "" {
return nil, errors.New("namespace path is required when using cni")
}
runtimeTags := policy.NewTagStore()
for _, tag := range event.Tags {
parts := strings.Split(tag, "=")
if len(parts) != 2 {
return nil, fmt.Errorf("invalid tag: %s", tag)
}
runtimeTags.AppendKeyValue("@usr:"+parts[0], parts[1])
}
runtimeIps := policy.ExtendedMap{"bridge": "0.0.0.0/0"}
return policy.NewPURuntime(event.Name, 1, "", runtimeTags, runtimeIps, common.LinuxProcessPU, nil), nil
} | go | func KubernetesMetadataExtractor(event *common.EventInfo) (*policy.PURuntime, error) {
if event.NS == "" {
return nil, errors.New("namespace path is required when using cni")
}
runtimeTags := policy.NewTagStore()
for _, tag := range event.Tags {
parts := strings.Split(tag, "=")
if len(parts) != 2 {
return nil, fmt.Errorf("invalid tag: %s", tag)
}
runtimeTags.AppendKeyValue("@usr:"+parts[0], parts[1])
}
runtimeIps := policy.ExtendedMap{"bridge": "0.0.0.0/0"}
return policy.NewPURuntime(event.Name, 1, "", runtimeTags, runtimeIps, common.LinuxProcessPU, nil), nil
} | [
"func",
"KubernetesMetadataExtractor",
"(",
"event",
"*",
"common",
".",
"EventInfo",
")",
"(",
"*",
"policy",
".",
"PURuntime",
",",
"error",
")",
"{",
"if",
"event",
".",
"NS",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
... | // KubernetesMetadataExtractor is a systemd based metadata extractor | [
"KubernetesMetadataExtractor",
"is",
"a",
"systemd",
"based",
"metadata",
"extractor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/cni/extractor.go#L13-L31 |
6,897 | aporeto-inc/trireme-lib | controller/pkg/cleaner/cleaner.go | CleanAllTriremeACLs | func CleanAllTriremeACLs() error {
ipt, err := iptablesctrl.NewInstance(fqconfig.NewFilterQueueWithDefaults(), constants.LocalServer, &runtime.Configuration{})
if err != nil {
return fmt.Errorf("unable to initialize cleaning iptables controller: %s", err)
}
return ipt.CleanUp()
} | go | func CleanAllTriremeACLs() error {
ipt, err := iptablesctrl.NewInstance(fqconfig.NewFilterQueueWithDefaults(), constants.LocalServer, &runtime.Configuration{})
if err != nil {
return fmt.Errorf("unable to initialize cleaning iptables controller: %s", err)
}
return ipt.CleanUp()
} | [
"func",
"CleanAllTriremeACLs",
"(",
")",
"error",
"{",
"ipt",
",",
"err",
":=",
"iptablesctrl",
".",
"NewInstance",
"(",
"fqconfig",
".",
"NewFilterQueueWithDefaults",
"(",
")",
",",
"constants",
".",
"LocalServer",
",",
"&",
"runtime",
".",
"Configuration",
"... | // CleanAllTriremeACLs cleans up all previous Trireme ACLs. It can be called from
// other packages for housekeeping. | [
"CleanAllTriremeACLs",
"cleans",
"up",
"all",
"previous",
"Trireme",
"ACLs",
".",
"It",
"can",
"be",
"called",
"from",
"other",
"packages",
"for",
"housekeeping",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/cleaner/cleaner.go#L14-L21 |
6,898 | aporeto-inc/trireme-lib | policy/types.go | ActionString | func (f ActionType) ActionString() string {
if f.Accepted() && !f.Rejected() {
return actionAccept
}
if !f.Accepted() && f.Rejected() {
return actionReject
}
return actionPassthrough
} | go | func (f ActionType) ActionString() string {
if f.Accepted() && !f.Rejected() {
return actionAccept
}
if !f.Accepted() && f.Rejected() {
return actionReject
}
return actionPassthrough
} | [
"func",
"(",
"f",
"ActionType",
")",
"ActionString",
"(",
")",
"string",
"{",
"if",
"f",
".",
"Accepted",
"(",
")",
"&&",
"!",
"f",
".",
"Rejected",
"(",
")",
"{",
"return",
"actionAccept",
"\n",
"}",
"\n\n",
"if",
"!",
"f",
".",
"Accepted",
"(",
... | // ActionString returns if the action if accepted of rejected as a long string. | [
"ActionString",
"returns",
"if",
"the",
"action",
"if",
"accepted",
"of",
"rejected",
"as",
"a",
"long",
"string",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L73-L83 |
6,899 | aporeto-inc/trireme-lib | policy/types.go | LogPrefix | func (f *FlowPolicy) LogPrefix(contextID string) string {
prefix := contextID + ":" + f.PolicyID + ":" + f.ServiceID + f.EncodedActionString()
return prefix
} | go | func (f *FlowPolicy) LogPrefix(contextID string) string {
prefix := contextID + ":" + f.PolicyID + ":" + f.ServiceID + f.EncodedActionString()
return prefix
} | [
"func",
"(",
"f",
"*",
"FlowPolicy",
")",
"LogPrefix",
"(",
"contextID",
"string",
")",
"string",
"{",
"prefix",
":=",
"contextID",
"+",
"\"",
"\"",
"+",
"f",
".",
"PolicyID",
"+",
"\"",
"\"",
"+",
"f",
".",
"ServiceID",
"+",
"f",
".",
"EncodedAction... | // LogPrefix is the prefix used in nf-log action. It must be less than | [
"LogPrefix",
"is",
"the",
"prefix",
"used",
"in",
"nf",
"-",
"log",
"action",
".",
"It",
"must",
"be",
"less",
"than"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L170-L173 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.