id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
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",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"NewRPCClient",
")",
",",
"contextID",
",",
"channel",
",",
"rpcSecret",
")",
"\n",
"}"
] | // 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",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"rpcwrapper",
".",
"RPCHdl",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // 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",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"methodName",
",",
"req",
",",
"resp",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"RemoteCall",
")",
",",
"contextID",
",",
"methodName",
",",
"req",
",",
"resp",
")",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"DestroyRPCClient",
")",
",",
"contextID",
")",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"[",
"]",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"CheckValidity",
")",
",",
"req",
",",
"secret",
")",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"ctx",
",",
"protocol",
",",
"path",
",",
"handler",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCServer",
")",
"(",
"nil",
")",
".",
"StartServer",
")",
",",
"ctx",
",",
"protocol",
",",
"path",
",",
"handler",
")",
"\n",
"}"
] | // 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",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCServer",
")",
"(",
"nil",
")",
".",
"ProcessMessage",
")",
",",
"req",
",",
"secret",
")",
"\n",
"}"
] | // 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",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"pod",
".",
"Spec",
".",
"NodeName",
"!=",
"w",
".",
"nodeName",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"pod",
".",
"Spec",
".",
"HostNetwork",
"&&",
"!",
"w",
".",
"enableHostPods",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"reconcile",
".",
"Request",
"{",
"{",
"NamespacedName",
":",
"types",
".",
"NamespacedName",
"{",
"Name",
":",
"pod",
".",
"Name",
",",
"Namespace",
":",
"pod",
".",
"Namespace",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // 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",
"out",
"if",
"host",
"networking",
"is",
"requested",
"but",
"we",
"don",
"t",
"want",
"to",
"enable",
"those",
"."
] | 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",
">",
"0",
"{",
"validity",
"=",
"cacheValidity",
"\n",
"}",
"\n\n",
"return",
"&",
"tokenManager",
"{",
"publicKeys",
":",
"publicKeys",
",",
"signMethod",
":",
"jwt",
".",
"SigningMethodES256",
",",
"keycache",
":",
"cache",
".",
"NewCacheWithExpiration",
"(",
"\"",
"\"",
",",
"validity",
")",
",",
"validity",
":",
"validity",
",",
"}",
"\n",
"}"
] | // 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",
".",
"Get",
"(",
"tokenString",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"pk",
".",
"(",
"*",
"DatapathKey",
")",
",",
"err",
"\n",
"}",
"\n\n",
"claims",
":=",
"&",
"verifierClaims",
"{",
"}",
"\n",
"var",
"JWTToken",
"*",
"jwt",
".",
"Token",
"\n",
"var",
"err",
"error",
"\n",
"for",
"_",
",",
"pk",
":=",
"range",
"p",
".",
"publicKeys",
"{",
"if",
"pk",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"JWTToken",
",",
"err",
"=",
"jwt",
".",
"ParseWithClaims",
"(",
"tokenString",
",",
"claims",
",",
"func",
"(",
"_",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// nolint",
"return",
"pk",
",",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"!",
"JWTToken",
".",
"Valid",
"{",
"continue",
"\n",
"}",
"\n\n",
"dp",
":=",
"&",
"DatapathKey",
"{",
"PublicKey",
":",
"KeyFromClaims",
"(",
"claims",
")",
",",
"Tags",
":",
"claims",
".",
"Tags",
",",
"}",
"\n\n",
"if",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"p",
".",
"validity",
")",
".",
"Unix",
"(",
")",
"<=",
"claims",
".",
"ExpiresAt",
"{",
"p",
".",
"keycache",
".",
"AddOrUpdate",
"(",
"tokenString",
",",
"dp",
")",
"\n",
"}",
"\n",
"return",
"dp",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // 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 claims",
"claims",
":=",
"&",
"verifierClaims",
"{",
"X",
":",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
".",
"X",
",",
"Y",
":",
"cert",
".",
"PublicKey",
".",
"(",
"*",
"ecdsa",
".",
"PublicKey",
")",
".",
"Y",
",",
"Tags",
":",
"tags",
",",
"}",
"\n",
"claims",
".",
"ExpiresAt",
"=",
"cert",
".",
"NotAfter",
".",
"Unix",
"(",
")",
"\n\n",
"// Create the token and sign with our key",
"strtoken",
",",
"err",
":=",
"jwt",
".",
"NewWithClaims",
"(",
"p",
".",
"signMethod",
",",
"claims",
")",
".",
"SignedString",
"(",
"p",
".",
"privateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"byte",
"(",
"strtoken",
")",
",",
"nil",
"\n",
"}"
] | // 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",
":",
"claims",
".",
"Y",
",",
"}",
"\n",
"}"
] | // 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",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
")",
"*",
"Proxy",
"{",
"localIPs",
":=",
"markedconn",
".",
"GetInterfaces",
"(",
")",
"\n\n",
"return",
"&",
"Proxy",
"{",
"collector",
":",
"c",
",",
"tokenaccessor",
":",
"tp",
",",
"puContext",
":",
"puContext",
",",
"registry",
":",
"registry",
",",
"localIPs",
":",
"localIPs",
",",
"certificate",
":",
"certificate",
",",
"ca",
":",
"caPool",
",",
"}",
"\n",
"}"
] | // 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",
"(",
"ctx",
",",
"listener",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"certificate",
"=",
"cert",
"\n",
"p",
".",
"ca",
"=",
"caPool",
"\n",
"}"
] | // 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",
".",
"(",
"*",
"markedconn",
".",
"ProxiedConnection",
")",
".",
"GetOriginalDestination",
"(",
")",
"\n\n",
"downConn",
",",
"err",
":=",
"p",
".",
"downConnection",
"(",
"ctx",
",",
"ip",
",",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"flowproperties",
":=",
"&",
"proxyFlowProperties",
"{",
"DestIP",
":",
"ip",
".",
"String",
"(",
")",
",",
"DestPort",
":",
"uint16",
"(",
"port",
")",
",",
"SourceIP",
":",
"upConn",
".",
"RemoteAddr",
"(",
")",
".",
"(",
"*",
"net",
".",
"TCPAddr",
")",
".",
"IP",
".",
"String",
"(",
")",
",",
"DestType",
":",
"collector",
".",
"EndPointTypeExternalIP",
",",
"SourceType",
":",
"collector",
".",
"EnpointTypePU",
",",
"}",
"\n\n",
"puContext",
",",
"perr",
":=",
"p",
".",
"puContextFromContextID",
"(",
"p",
".",
"puContext",
")",
"\n",
"if",
"perr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"p",
".",
"puContext",
")",
",",
"zap",
".",
"Error",
"(",
"perr",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"p",
".",
"reportRejectedFlow",
"(",
"flowproperties",
",",
"puContext",
".",
"ManagementID",
"(",
")",
",",
"\"",
"\"",
",",
"puContext",
",",
"collector",
".",
"UnableToDial",
",",
"nil",
",",
"nil",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"downConn",
".",
"Close",
"(",
")",
"// nolint",
"\n\n",
"// Now let us handle the state machine for the down connection",
"isEncrypted",
",",
"err",
":=",
"p",
".",
"CompleteEndPointAuthorization",
"(",
"ip",
",",
"port",
",",
"upConn",
",",
"downConn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"proxyData",
"(",
"ctx",
",",
"isEncrypted",
",",
"upConn",
",",
"downConn",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"{",
"IP",
":",
"ip",
",",
"Port",
":",
"port",
",",
"}",
"\n\n",
"return",
"markedconn",
".",
"DialMarkedWithContext",
"(",
"ctx",
",",
"\"",
"\"",
",",
"raddr",
".",
"String",
"(",
")",
",",
"proxyMarkInt",
")",
"\n\n",
"}"
] | // 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",
"}",
"\n\n",
"podNamespace",
":=",
"pod",
".",
"GetNamespace",
"(",
")",
"\n",
"podName",
":=",
"pod",
".",
"GetName",
"(",
")",
"\n\n",
"puIDs",
":=",
"m",
".",
"cache",
".",
"getPUIDsbyPod",
"(",
"podNamespace",
",",
"podName",
")",
"\n\n",
"for",
"_",
",",
"puid",
":=",
"range",
"puIDs",
"{",
"dockerRuntime",
":=",
"m",
".",
"cache",
".",
"getDockerRuntimeByPUID",
"(",
"puid",
")",
"\n",
"if",
"dockerRuntime",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"kubernetesRuntime",
",",
"managedContainer",
",",
"err",
":=",
"m",
".",
"kubernetesExtractor",
"(",
"dockerRuntime",
",",
"pod",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"podNamespace",
",",
"podName",
",",
"puid",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// UnmanagedContainers are simply ignored. It should not come this far if it is a non managed container anyways.",
"if",
"!",
"managedContainer",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"puid",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"podNamespace",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"podName",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// We keep the cache uptoDate for future queries",
"m",
".",
"cache",
".",
"updatePUIDCache",
"(",
"podNamespace",
",",
"podName",
",",
"puid",
",",
"dockerRuntime",
",",
"kubernetesRuntime",
")",
"\n\n",
"if",
"err",
":=",
"m",
".",
"handlers",
".",
"Policy",
".",
"HandlePUEvent",
"(",
"ctx",
",",
"puid",
",",
"common",
".",
"EventUpdate",
",",
"kubernetesRuntime",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\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",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"podName",
",",
"ok",
":=",
"runtime",
".",
"Tag",
"(",
"KubernetesPodNameIdentifier",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"podNamespace",
",",
"podName",
",",
"nil",
"\n",
"}"
] | // 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",
")",
"{",
"// Do nothing on other events apart from start event.",
"if",
"event",
"!=",
"common",
".",
"EventStart",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"puRuntime",
",",
"ok",
":=",
"runtimeInfo",
".",
"(",
"*",
"policy",
".",
"PURuntime",
")",
"\n",
"if",
"!",
"ok",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"puID",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"puID",
")",
"\n",
"}",
"\n\n",
"extensions",
":=",
"policy",
".",
"ExtendedMap",
"{",
"}",
"\n\n",
"// pause container with host net set to true.",
"if",
"runtimeInfo",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"LinuxProcessPU",
"{",
"extensions",
"[",
"constants",
".",
"DockerHostMode",
"]",
"=",
"\"",
"\"",
"\n",
"extensions",
"[",
"constants",
".",
"DockerHostPUID",
"]",
"=",
"puID",
"\n",
"options",
":=",
"puRuntime",
".",
"Options",
"(",
")",
"\n",
"options",
".",
"PolicyExtensions",
"=",
"extensions",
"\n\n",
"// set Options on docker runtime.",
"puRuntime",
".",
"SetOptions",
"(",
"options",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"pausePUID",
":=",
"\"",
"\"",
"\n",
"puIDs",
":=",
"m",
".",
"cache",
".",
"getPUIDsbyPod",
"(",
"podNamespace",
",",
"podName",
")",
"\n",
"// get the puid of the pause container.",
"for",
"_",
",",
"id",
":=",
"range",
"puIDs",
"{",
"rtm",
":=",
"m",
".",
"cache",
".",
"getDockerRuntimeByPUID",
"(",
"id",
")",
"\n",
"if",
"rtm",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"isPodInfraContainer",
"(",
"rtm",
")",
"&&",
"rtm",
".",
"PUType",
"(",
")",
"==",
"common",
".",
"LinuxProcessPU",
"{",
"pausePUID",
"=",
"id",
"\n",
"break",
"\n",
"}",
"\n\n",
"// if the pause container is not host net container, nothing to do.",
"if",
"isPodInfraContainer",
"(",
"rtm",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"extensions",
"[",
"constants",
".",
"DockerHostPUID",
"]",
"=",
"pausePUID",
"\n",
"options",
":=",
"puRuntime",
".",
"Options",
"(",
")",
"\n",
"options",
".",
"PolicyExtensions",
"=",
"extensions",
"\n",
"// set Options on docker runtime.",
"puRuntime",
".",
"SetOptions",
"(",
"options",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
".",
"TypeOf",
"(",
"(",
"*",
"MockStatsClient",
")",
"(",
"nil",
")",
".",
"SendStats",
")",
")",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"udpPacketType",
":=",
"udpPacket",
".",
"GetUDPType",
"(",
")",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Send the return packet.",
"if",
"err",
"=",
"d",
".",
"sendUDPSynAckPacket",
"(",
"udpPacket",
",",
"context",
",",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Mark the state that we have transmitted a SynAck packet.",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPReceiverSendSynAck",
")",
"\n",
"return",
"action",
",",
"claims",
",",
"nil",
"\n\n",
"case",
"packet",
".",
"UDPAckMask",
":",
"// Retrieve the header and parse the signatures.",
"if",
"err",
"=",
"d",
".",
"processNetworkUDPAckPacket",
"(",
"udpPacket",
",",
"context",
",",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Set the connection to",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPReceiverProcessedAck",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n\n",
"case",
"packet",
".",
"UDPSynAckMask",
":",
"// Process the synack header and claims of the other side.",
"action",
",",
"claims",
",",
"err",
"=",
"d",
".",
"processNetworkUDPSynAckPacket",
"(",
"udpPacket",
",",
"context",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Send back the acknowledgement.",
"err",
"=",
"d",
".",
"sendUDPAckPacket",
"(",
"udpPacket",
",",
"context",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPClientSendAck",
")",
"\n\n",
"return",
"action",
",",
"claims",
",",
"nil",
"\n\n",
"default",
":",
"state",
":=",
"conn",
".",
"GetState",
"(",
")",
"\n",
"if",
"state",
"==",
"connection",
".",
"UDPReceiverProcessedAck",
"||",
"state",
"==",
"connection",
".",
"UDPClientSendAck",
"||",
"state",
"==",
"connection",
".",
"UDPData",
"{",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPData",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"state",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"p",
".",
"L4FlowHash",
"(",
")",
")",
",",
")",
"\n",
"defer",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"p",
".",
"L4FlowHash",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"// First retrieve the connection state.",
"conn",
",",
"err",
"=",
"d",
".",
"appUDPRetrieveState",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// We are processing only one packet from a given connection at a time.",
"conn",
".",
"Lock",
"(",
")",
"\n",
"defer",
"conn",
".",
"Unlock",
"(",
")",
"\n\n",
"// do some pre processing.",
"if",
"d",
".",
"service",
"!=",
"nil",
"{",
"// PreProcessServiceInterface",
"if",
"!",
"d",
".",
"service",
".",
"PreProcessUDPAppPacket",
"(",
"p",
",",
"conn",
".",
"Context",
",",
"conn",
",",
"packet",
".",
"UDPSynMask",
")",
"{",
"p",
".",
"Print",
"(",
"packet",
".",
"PacketFailureService",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"triggerControlProtocol",
":=",
"false",
"\n",
"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",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"p",
".",
"L4FlowHash",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"// Set the state indicating that we send out a Syn packet",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPClientSendSyn",
")",
"\n",
"// Drop the packet. We stored it in the queue.",
"triggerControlProtocol",
"=",
"true",
"\n\n",
"case",
"connection",
".",
"UDPReceiverProcessedAck",
",",
"connection",
".",
"UDPClientSendAck",
",",
"connection",
".",
"UDPData",
":",
"conn",
".",
"SetState",
"(",
"connection",
".",
"UDPData",
")",
"\n\n",
"default",
":",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"p",
".",
"L4FlowHash",
"(",
")",
")",
")",
"\n",
"if",
"err",
"=",
"conn",
".",
"QueuePackets",
"(",
"p",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"d",
".",
"service",
"!=",
"nil",
"{",
"// PostProcessServiceInterface",
"if",
"!",
"d",
".",
"service",
".",
"PostProcessUDPAppPacket",
"(",
"p",
",",
"nil",
",",
"conn",
".",
"Context",
",",
"conn",
")",
"{",
"p",
".",
"Print",
"(",
"packet",
".",
"PacketFailureService",
")",
"\n",
"return",
"conn",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"triggerControlProtocol",
"{",
"err",
"=",
"d",
".",
"triggerNegotiation",
"(",
"p",
",",
"conn",
".",
"Context",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"err",
"\n",
"}",
"\n",
"return",
"conn",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // 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",
")",
"{",
"udpOptions",
":=",
"packet",
".",
"CreateUDPAuthMarker",
"(",
"packet",
".",
"UDPSynMask",
")",
"\n\n",
"udpData",
",",
"err",
":=",
"d",
".",
"tokenAccessor",
".",
"CreateSynPacketToken",
"(",
"context",
",",
"&",
"conn",
".",
"Auth",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"newPacket",
",",
"err",
":=",
"d",
".",
"clonePacketHeaders",
"(",
"udpPacket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// Attach the UDP data and token",
"newPacket",
".",
"UDPTokenAttach",
"(",
"udpOptions",
",",
"udpData",
")",
"\n\n",
"// send packet",
"err",
"=",
"d",
".",
"writeWithRetransmit",
"(",
"newPacket",
".",
"GetBuffer",
"(",
"0",
")",
",",
"conn",
",",
"conn",
".",
"SynChannel",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Populate the caches to track the connection",
"hash",
":=",
"udpPacket",
".",
"L4FlowHash",
"(",
")",
"\n",
"d",
".",
"udpAppOrigConnectionTracker",
".",
"AddOrUpdate",
"(",
"hash",
",",
"conn",
")",
"\n",
"d",
".",
"udpSourcePortConnectionCache",
".",
"AddOrUpdate",
"(",
"newPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeApplication",
")",
",",
"conn",
")",
"\n",
"d",
".",
"udpNatConnectionTracker",
".",
"AddOrUpdate",
"(",
"newPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeApplication",
")",
",",
"newPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeNetwork",
")",
")",
"\n\n",
"return",
"nil",
"\n\n",
"}"
] | // 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",
")",
"{",
"// Create UDP Option",
"udpOptions",
":=",
"packet",
".",
"CreateUDPAuthMarker",
"(",
"packet",
".",
"UDPSynAckMask",
")",
"\n\n",
"udpData",
",",
"err",
":=",
"d",
".",
"tokenAccessor",
".",
"CreateSynAckPacketToken",
"(",
"context",
",",
"&",
"conn",
".",
"Auth",
",",
"claimsheader",
".",
"NewClaimsHeader",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"udpPacket",
".",
"CreateReverseFlowPacket",
"(",
"udpPacket",
".",
"SourceAddress",
"(",
")",
",",
"udpPacket",
".",
"SourcePort",
"(",
")",
")",
"\n\n",
"// Attach the UDP data and token",
"udpPacket",
".",
"UDPTokenAttach",
"(",
"udpOptions",
",",
"udpData",
")",
"\n\n",
"// 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",
"(",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"claims",
"*",
"tokens",
".",
"ConnectionClaims",
",",
"err",
"error",
")",
"{",
"claims",
",",
"err",
"=",
"d",
".",
"tokenAccessor",
".",
"ParsePacketToken",
"(",
"&",
"conn",
".",
"Auth",
",",
"udpPacket",
".",
"ReadUDPToken",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"d",
".",
"reportUDPRejectedFlow",
"(",
"udpPacket",
",",
"conn",
",",
"collector",
".",
"DefaultEndPoint",
",",
"context",
".",
"ManagementID",
"(",
")",
",",
"context",
",",
"tokens",
".",
"CodeFromErr",
"(",
"err",
")",
",",
"nil",
",",
"nil",
",",
"false",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Why is this required. Take a look.",
"txLabel",
",",
"_",
":=",
"claims",
".",
"T",
".",
"Get",
"(",
"enforcerconstants",
".",
"TransmitterLabel",
")",
"\n\n",
"// 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",
"(",
")",
")",
")",
")",
"\n\n",
"report",
",",
"pkt",
":=",
"context",
".",
"SearchRcvRules",
"(",
"claims",
".",
"T",
")",
"\n",
"if",
"pkt",
".",
"Action",
".",
"Rejected",
"(",
")",
"{",
"d",
".",
"reportUDPRejectedFlow",
"(",
"udpPacket",
",",
"conn",
",",
"txLabel",
",",
"context",
".",
"ManagementID",
"(",
")",
",",
"context",
",",
"collector",
".",
"PolicyDrop",
",",
"report",
",",
"pkt",
",",
"false",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"claims",
".",
"T",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"hash",
":=",
"udpPacket",
".",
"L4FlowHash",
"(",
")",
"\n\n",
"// conntrack",
"d",
".",
"udpNetOrigConnectionTracker",
".",
"AddOrUpdate",
"(",
"hash",
",",
"conn",
")",
"\n",
"d",
".",
"udpAppReplyConnectionTracker",
".",
"AddOrUpdate",
"(",
"udpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
",",
"conn",
")",
"\n\n",
"// Record actions",
"conn",
".",
"ReportFlowPolicy",
"=",
"report",
"\n",
"conn",
".",
"PacketFlowPolicy",
"=",
"pkt",
"\n\n",
"return",
"pkt",
",",
"claims",
",",
"nil",
"\n",
"}"
] | // 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",
")",
"\n\n",
"udpPacket",
".",
"CreateReverseFlowPacket",
"(",
"udpPacket",
".",
"SourceAddress",
"(",
")",
",",
"udpPacket",
".",
"SourcePort",
"(",
")",
")",
"\n\n",
"// Attach the UDP data and token",
"udpPacket",
".",
"UDPTokenAttach",
"(",
"udpOptions",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Info",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"udpPacket",
".",
"L4FlowHash",
"(",
")",
")",
")",
"\n",
"// no need for retransmits here.",
"err",
"=",
"d",
".",
"udpSocketWriter",
".",
"WriteSocket",
"(",
"udpPacket",
".",
"GetBuffer",
"(",
"0",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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 to change the connmark label again.",
"if",
"d",
".",
"udpFinPacketTracker",
".",
"AddOrUpdate",
"(",
"udpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
",",
"true",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// clear cache entries.",
"if",
"err",
":=",
"d",
".",
"udpAppOrigConnectionTracker",
".",
"Remove",
"(",
"udpPacket",
".",
"L4ReverseFlowHash",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"udpSourcePortConnectionCache",
".",
"Remove",
"(",
"udpPacket",
".",
"SourcePortHash",
"(",
"packet",
".",
"PacketTypeNetwork",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"udpPacket",
".",
"L4FlowHash",
"(",
")",
")",
")",
"\n",
"if",
"err",
"=",
"d",
".",
"conntrack",
".",
"UpdateNetworkFlowMark",
"(",
"udpPacket",
".",
"SourceAddress",
"(",
")",
",",
"udpPacket",
".",
"DestinationAddress",
"(",
")",
",",
"udpPacket",
".",
"IPProto",
"(",
")",
",",
"udpPacket",
".",
"SourcePort",
"(",
")",
",",
"udpPacket",
".",
"DestPort",
"(",
")",
",",
"constants",
".",
"DeleteConnmark",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"udpPacket",
".",
"L4FlowHash",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"statsclient",
".",
"StatsClient",
",",
"collector",
"statscollector",
".",
"Collector",
",",
"debugClient",
"debugclient",
".",
"DebugClient",
",",
")",
"(",
"*",
"RemoteEnforcer",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"if",
"collector",
"==",
"nil",
"{",
"collector",
"=",
"statscollector",
".",
"NewCollector",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"statsClient",
"==",
"nil",
"{",
"statsClient",
",",
"err",
"=",
"statsclient",
".",
"NewStatsClient",
"(",
"collector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"debugClient",
"==",
"nil",
"{",
"debugClient",
",",
"err",
"=",
"debugclient",
".",
"NewDebugClient",
"(",
"collector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"procMountPoint",
":=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvMountPoint",
")",
"\n",
"if",
"procMountPoint",
"==",
"\"",
"\"",
"{",
"procMountPoint",
"=",
"constants",
".",
"DefaultProcMountPoint",
"\n",
"}",
"\n\n",
"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",
"\n",
"}"
] | // 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",
".",
"rpcSecret",
")",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"cmdLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cmdLock",
".",
"Unlock",
"(",
")",
"\n\n",
"payload",
",",
"ok",
":=",
"req",
".",
"Payload",
".",
"(",
"rpcwrapper",
".",
"EnforcePayload",
")",
"\n",
"if",
"!",
"ok",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"plc",
",",
"err",
":=",
"payload",
".",
"Policy",
".",
"ToPrivatePolicy",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"puInfo",
":=",
"&",
"policy",
".",
"PUInfo",
"{",
"ContextID",
":",
"payload",
".",
"ContextID",
",",
"Policy",
":",
"plc",
",",
"Runtime",
":",
"policy",
".",
"NewPURuntimeWithDefaults",
"(",
")",
",",
"}",
"\n\n",
"if",
"s",
".",
"enforcer",
"==",
"nil",
"||",
"s",
".",
"supervisor",
"==",
"nil",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
"=",
"s",
".",
"supervisor",
".",
"Supervise",
"(",
"payload",
".",
"ContextID",
",",
"puInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Status",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"s",
".",
"enforcer",
".",
"Enforce",
"(",
"payload",
".",
"ContextID",
",",
"puInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Status",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"rpcSecret",
")",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"cmdLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cmdLock",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"statsClient",
".",
"SendStats",
"(",
")",
"\n\n",
"payload",
",",
"ok",
":=",
"req",
".",
"Payload",
".",
"(",
"rpcwrapper",
".",
"UnEnforcePayload",
")",
"\n",
"if",
"!",
"ok",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n\n",
"// 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",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
"=",
"s",
".",
"supervisor",
".",
"Unsupervise",
"(",
"payload",
".",
"ContextID",
")",
";",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Status",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"s",
".",
"enforcer",
".",
"Unenforce",
"(",
"payload",
".",
"ContextID",
")",
";",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Status",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"CheckValidity",
"(",
"&",
"req",
",",
"s",
".",
"rpcSecret",
")",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"//nolint",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"cmdLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cmdLock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"enforcer",
"==",
"nil",
"||",
"s",
".",
"supervisor",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"payload",
":=",
"req",
".",
"Payload",
".",
"(",
"rpcwrapper",
".",
"SetTargetNetworksPayload",
")",
"\n\n",
"// 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",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
"=",
"s",
".",
"enforcer",
".",
"SetTargetNetworks",
"(",
"payload",
".",
"Configuration",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"s",
".",
"supervisor",
".",
"SetTargetNetworks",
"(",
"payload",
".",
"Configuration",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // 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",
"return",
"nil",
"\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",
".",
"CheckValidity",
"(",
"&",
"req",
",",
"s",
".",
"rpcSecret",
")",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"cmdLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cmdLock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"enforcer",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"payload",
":=",
"req",
".",
"Payload",
".",
"(",
"rpcwrapper",
".",
"UpdateSecretsPayload",
")",
"\n",
"s",
".",
"secrets",
",",
"err",
"=",
"secrets",
".",
"NewSecrets",
"(",
"payload",
".",
"Secrets",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"s",
".",
"enforcer",
".",
"UpdateSecrets",
"(",
"s",
".",
"secrets",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // 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",
"(",
"&",
"req",
",",
"s",
".",
"rpcSecret",
")",
"{",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"resp",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"cmdLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cmdLock",
".",
"Unlock",
"(",
")",
"\n\n",
"payload",
":=",
"req",
".",
"Payload",
".",
"(",
"rpcwrapper",
".",
"EnableIPTablesPacketTracingPayLoad",
")",
"\n\n",
"if",
"err",
":=",
"s",
".",
"supervisor",
".",
"EnableIPTablesPacketTracing",
"(",
"context",
".",
"Background",
"(",
")",
",",
"payload",
".",
"ContextID",
",",
"payload",
".",
"Interval",
")",
";",
"err",
"!=",
"nil",
"{",
"resp",
".",
"Status",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"resp",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"Secrets",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"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",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"enforcer",
"!=",
"nil",
"{",
"if",
"err",
":=",
"s",
".",
"enforcer",
".",
"CleanUp",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"service",
"!=",
"nil",
"{",
"if",
"err",
":=",
"s",
".",
"service",
".",
"Stop",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"cancel",
"(",
")",
"\n",
"}"
] | // 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",
"err",
"\n",
"}",
"\n\n",
"ctx",
",",
"cancelMainCtx",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancelMainCtx",
"(",
")",
"\n\n",
"namedPipe",
":=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvContextSocket",
")",
"\n",
"secret",
":=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvRPCClientSecret",
")",
"\n",
"if",
"secret",
"==",
"\"",
"\"",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"flag",
":=",
"unix",
".",
"SIGHUP",
"\n",
"if",
"err",
":=",
"unix",
".",
"Prctl",
"(",
"unix",
".",
"PR_SET_PDEATHSIG",
",",
"uintptr",
"(",
"flag",
")",
",",
"0",
",",
"0",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"rpcHandle",
":=",
"rpcwrapper",
".",
"NewRPCServer",
"(",
")",
"\n",
"re",
",",
"err",
":=",
"newRemoteEnforcer",
"(",
"ctx",
",",
"cancelMainCtx",
",",
"service",
",",
"rpcHandle",
",",
"secret",
",",
"nil",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"rpcHandle",
".",
"StartServer",
"(",
"ctx",
",",
"\"",
"\"",
",",
"namedPipe",
",",
"re",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"c",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"c",
",",
"syscall",
".",
"SIGTERM",
",",
"syscall",
".",
"SIGINT",
",",
"syscall",
".",
"SIGQUIT",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"c",
":",
"re",
".",
"cleanup",
"(",
")",
"\n\n",
"case",
"<-",
"re",
".",
"exit",
":",
"zap",
".",
"L",
"(",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"GoString",
"(",
"val",
")",
"\n",
"}"
] | // 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",
"{",
"}",
",",
"ID",
":",
"id",
",",
"External",
":",
"external",
",",
"}",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"sc",
":=",
"&",
"scopeRule",
"{",
"rule",
":",
"rule",
",",
"}",
"\n",
"for",
"_",
",",
"method",
":=",
"range",
"rule",
".",
"Methods",
"{",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"methodRoots",
"[",
"method",
"]",
";",
"!",
"ok",
"{",
"a",
".",
"methodRoots",
"[",
"method",
"]",
"=",
"&",
"node",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"uri",
":=",
"range",
"rule",
".",
"URIs",
"{",
"insert",
"(",
"a",
".",
"methodRoots",
"[",
"method",
"]",
",",
"uri",
",",
"sc",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"a",
"\n",
"}"
] | // 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",
"rule",
"==",
"nil",
"{",
"return",
"found",
",",
"nil",
"\n",
"}",
"\n",
"if",
"policyRule",
",",
"ok",
":=",
"rule",
".",
"(",
"*",
"scopeRule",
")",
";",
"ok",
"{",
"return",
"found",
",",
"policyRule",
".",
"rule",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // 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",
")",
"\n",
"if",
"!",
"found",
"||",
"rule",
"==",
"nil",
"{",
"return",
"false",
",",
"false",
"\n",
"}",
"\n",
"policyRule",
",",
"ok",
":=",
"rule",
".",
"(",
"*",
"scopeRule",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
",",
"false",
"\n",
"}",
"\n",
"if",
"policyRule",
".",
"rule",
".",
"Public",
"{",
"return",
"true",
",",
"true",
"\n",
"}",
"\n",
"return",
"c",
".",
"MatchClaims",
"(",
"policyRule",
".",
"rule",
".",
"ClaimMatchingRules",
",",
"attributes",
")",
",",
"false",
"\n",
"}"
] | // 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",
"how",
"to",
"present",
"the",
"data",
"or",
"potentially",
"what",
"to",
"do",
"if",
"authorization",
"fails",
"."
] | 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",
"_",
",",
"claim",
":=",
"range",
"claims",
"{",
"claimsMap",
"[",
"claim",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n\n",
"var",
"matched",
"int",
"\n",
"for",
"_",
",",
"clause",
":=",
"range",
"rules",
"{",
"matched",
"=",
"len",
"(",
"clause",
")",
"\n",
"for",
"_",
",",
"claim",
":=",
"range",
"clause",
"{",
"if",
"_",
",",
"ok",
":=",
"claimsMap",
"[",
"claim",
"]",
";",
"ok",
"{",
"matched",
"--",
"\n",
"}",
"\n",
"if",
"matched",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // 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",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"search",
"(",
"root",
",",
"uri",
")",
"\n",
"}"
] | // 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",
"++",
"{",
"if",
"s",
"[",
"i",
"]",
"==",
"'/'",
"{",
"return",
"s",
"[",
"0",
":",
"i",
"]",
",",
"s",
"[",
"i",
":",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"s",
",",
"\"",
"\"",
"\n",
"}"
] | // 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",
"}",
"\n\n",
"prefix",
",",
"suffix",
":=",
"parse",
"(",
"api",
")",
"\n\n",
"// root node or terminal node",
"if",
"prefix",
"==",
"\"",
"\"",
"{",
"n",
".",
"data",
"=",
"data",
"\n",
"n",
".",
"leaf",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"n",
".",
"children",
"==",
"nil",
"{",
"n",
".",
"children",
"=",
"map",
"[",
"string",
"]",
"*",
"node",
"{",
"}",
"\n",
"}",
"\n\n",
"// If there is no child, add the new child.",
"next",
",",
"ok",
":=",
"n",
".",
"children",
"[",
"prefix",
"]",
"\n",
"if",
"!",
"ok",
"{",
"next",
"=",
"&",
"node",
"{",
"}",
"\n",
"n",
".",
"children",
"[",
"prefix",
"]",
"=",
"next",
"\n",
"}",
"\n\n",
"insert",
"(",
"next",
",",
"suffix",
",",
"data",
")",
"\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",
".",
"DockerHostPUID",
")",
";",
"ok",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"puid",
")",
")",
"\n",
"return",
"puid",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // 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",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"extensions",
",",
"ok",
":=",
"runtime",
".",
"Options",
"(",
")",
".",
"PolicyExtensions",
".",
"(",
"policy",
".",
"ExtendedMap",
")",
";",
"ok",
"{",
"return",
"extensions",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
")",
")",
"!=",
"\"",
"\"",
")",
"\n",
"}"
] | // 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",
"false",
"\n",
"}"
] | // 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",
":=",
"\"",
"\"",
"\n\n",
"podNamespace",
",",
"ok",
":=",
"labels",
"[",
"constants",
".",
"K8sPodNamespace",
"]",
"\n",
"if",
"!",
"ok",
"{",
"podNamespace",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"podName",
",",
"ok",
"=",
"labels",
"[",
"constants",
".",
"K8sPodName",
"]",
"\n",
"if",
"!",
"ok",
"{",
"podName",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"podName",
"==",
"\"",
"\"",
"||",
"podNamespace",
"==",
"\"",
"\"",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"podNamespace",
"+",
"\"",
"\"",
"+",
"podName",
"\n",
"}"
] | // 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",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ForwardingPolicy",
"{",
"}",
",",
"equalIDMapTable",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ForwardingPolicy",
"{",
"}",
",",
"notEqualMapTable",
":",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ForwardingPolicy",
"{",
"}",
",",
"notStarTable",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ForwardingPolicy",
"{",
"}",
",",
"defaultNotExistsPolicy",
":",
"nil",
",",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] | //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",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n\n",
"if",
"tag",
"[",
"0",
"]",
"==",
"'='",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"l",
";",
"i",
"++",
"{",
"if",
"tag",
"[",
"i",
"]",
"==",
"'='",
"{",
"if",
"i",
"+",
"1",
">=",
"l",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n",
"*",
"k",
"=",
"tag",
"[",
":",
"i",
"]",
"\n",
"*",
"v",
"=",
"tag",
"[",
"i",
"+",
"1",
":",
"]",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}"
] | // 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",
")",
"\n\n",
"skip",
":=",
"make",
"(",
"[",
"]",
"bool",
",",
"m",
".",
"numberOfPolicies",
"+",
"1",
")",
"\n\n",
"// Disable all policies that fail the not key exists",
"copiedTags",
":=",
"tags",
".",
"GetSlice",
"(",
")",
"\n",
"var",
"k",
",",
"v",
"string",
"\n\n",
"for",
"_",
",",
"t",
":=",
"range",
"copiedTags",
"{",
"if",
"err",
":=",
"m",
".",
"tagSplit",
"(",
"t",
",",
"&",
"k",
",",
"&",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"policy",
":=",
"range",
"m",
".",
"notStarTable",
"[",
"k",
"]",
"{",
"skip",
"[",
"policy",
".",
"index",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"tagSplit",
"(",
"t",
",",
"&",
"k",
",",
"&",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"// Search for matches of k=v",
"if",
"index",
",",
"action",
":=",
"searchInMapTable",
"(",
"m",
".",
"equalMapTable",
"[",
"k",
"]",
"[",
"v",
"]",
",",
"count",
",",
"skip",
")",
";",
"index",
">=",
"0",
"{",
"return",
"index",
",",
"action",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"if",
"index",
",",
"action",
":=",
"searchInMapTable",
"(",
"policies",
",",
"count",
",",
"skip",
")",
";",
"index",
">=",
"0",
"{",
"return",
"index",
",",
"action",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"defaultNotExistsPolicy",
"!=",
"nil",
"&&",
"!",
"skip",
"[",
"m",
".",
"defaultNotExistsPolicy",
".",
"index",
"]",
"{",
"return",
"m",
".",
"defaultNotExistsPolicy",
".",
"index",
",",
"m",
".",
"defaultNotExistsPolicy",
".",
"actions",
"\n",
"}",
"\n\n",
"return",
"-",
"1",
",",
"nil",
"\n",
"}"
] | // 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",
",",
"policies",
":=",
"range",
"values",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"policies",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"key",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"value",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"for",
"key",
",",
"values",
":=",
"range",
"m",
".",
"equalIDMapTable",
"{",
"for",
"_",
",",
"policies",
":=",
"range",
"values",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"policies",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"key",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"for",
"key",
",",
"values",
":=",
"range",
"m",
".",
"notEqualMapTable",
"{",
"for",
"value",
",",
"policies",
":=",
"range",
"values",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"policies",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"key",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"value",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"}"
] | // 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.",
"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",
",",
")",
"\n",
"}",
"\n\n",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"cgroupCaptureTemplate",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"cfg",
".",
"UDPPorts",
"!=",
"\"",
"\"",
"\n",
"}",
",",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"cfg",
".",
"TCPPorts",
"!=",
"\"",
"\"",
"\n",
"}",
",",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"cfg",
".",
"AppSection",
"==",
"HostModeOutput",
"&&",
"cfg",
".",
"NetSection",
"==",
"HostModeInput",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"cgroupCaptureTemplate",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"rules",
",",
"i",
".",
"proxyRules",
"(",
"cfg",
")",
"...",
")",
"\n",
"}"
] | // 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",
"(",
"containerChainTemplate",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"rules",
",",
"i",
".",
"proxyRules",
"(",
"cfg",
")",
"...",
")",
"\n",
"}"
] | // 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",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"cfg",
".",
"CgroupMark",
"!=",
"\"",
"\"",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"proxyChainTemplate",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"rules",
"\n",
"}"
] | // 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",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"i",
".",
"mode",
"==",
"constants",
".",
"Sidecar",
"||",
"isHostPU",
"||",
"i",
".",
"isLegacyKernel",
"\n",
"}",
",",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"cfg",
".",
"UID",
"!=",
"\"",
"\"",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"packetCaptureTemplate",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"rules",
"\n",
"}"
] | // 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",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"appChain",
",",
"i",
".",
"appPacketIPTableContext",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"NewChain",
"(",
"i",
".",
"netPacketIPTableContext",
",",
"netChain",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"netChain",
",",
"i",
".",
"netPacketIPTableContext",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"related",
"to",
"a",
"container",
"are",
"contained",
"within",
"the",
"dedicated",
"chain"
] | 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: 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",
"\"",
"\"",
":",
"if",
"err",
"=",
"i",
".",
"ipt",
".",
"Append",
"(",
"cr",
"[",
"0",
"]",
",",
"cr",
"[",
"1",
"]",
",",
"cr",
"[",
"2",
":",
"]",
"...",
")",
";",
"err",
"==",
"nil",
"{",
"break",
"L",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"order",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"cr",
"[",
"2",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"i",
".",
"ipt",
".",
"Insert",
"(",
"cr",
"[",
"0",
"]",
",",
"cr",
"[",
"1",
"]",
",",
"order",
",",
"cr",
"[",
"3",
":",
"]",
"...",
")",
";",
"err",
"==",
"nil",
"{",
"break",
"L",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
":",
"if",
"err",
"=",
"i",
".",
"ipt",
".",
"Delete",
"(",
"cr",
"[",
"0",
"]",
",",
"cr",
"[",
"1",
"]",
",",
"cr",
"[",
"2",
":",
"]",
"...",
")",
";",
"err",
"==",
"nil",
"{",
"break",
"L",
"\n",
"}",
"\n\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"methodType",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"methodType",
",",
"cr",
"[",
"0",
"]",
",",
"cr",
"[",
"1",
"]",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"rule",
".",
"ipset",
",",
"ipMatchDirection",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"rule",
".",
"ports",
",",
"\"",
"\"",
")",
",",
"}",
"\n\n",
"for",
"_",
",",
"ext",
":=",
"range",
"rule",
".",
"extensions",
"{",
"args",
",",
"err",
":=",
"shellwords",
".",
"Parse",
"(",
"ext",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ext",
",",
"err",
")",
"\n",
"}",
"\n\n",
"rulesspec",
"=",
"append",
"(",
"rulesspec",
",",
"args",
"...",
")",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"Append",
"(",
"i",
".",
"appPacketIPTableContext",
",",
"chain",
",",
"rulesspec",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
":=",
"&",
"rulesInfo",
"{",
"RejectObserveApply",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"RejectNotObserved",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"RejectObserveContinue",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"AcceptObserveApply",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"AcceptNotObserved",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"AcceptObserveContinue",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"ReverseRules",
":",
"[",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"direction",
":=",
"\"",
"\"",
"\n",
"reverse",
":=",
"\"",
"\"",
"\n",
"nflogGroup",
":=",
"\"",
"\"",
"\n",
"if",
"isAppACLs",
"{",
"direction",
"=",
"\"",
"\"",
"\n",
"reverse",
"=",
"\"",
"\"",
"\n",
"nflogGroup",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"for",
"_",
",",
"proto",
":=",
"range",
"rule",
".",
"protocols",
"{",
"acls",
",",
"r",
":=",
"i",
".",
"generateACLRules",
"(",
"contextID",
",",
"&",
"rule",
",",
"chain",
",",
"reverseChain",
",",
"nflogGroup",
",",
"proto",
",",
"direction",
",",
"reverse",
")",
"\n",
"rulesBucket",
".",
"ReverseRules",
"=",
"append",
"(",
"rulesBucket",
".",
"ReverseRules",
",",
"r",
"...",
")",
"\n\n",
"if",
"testReject",
"(",
"rule",
".",
"policy",
")",
"&&",
"testObserveApply",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"RejectObserveApply",
"=",
"append",
"(",
"rulesBucket",
".",
"RejectObserveApply",
",",
"acls",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"testReject",
"(",
"rule",
".",
"policy",
")",
"&&",
"testNotObserved",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"RejectNotObserved",
"=",
"append",
"(",
"rulesBucket",
".",
"RejectNotObserved",
",",
"acls",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"testReject",
"(",
"rule",
".",
"policy",
")",
"&&",
"testObserveContinue",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"RejectObserveContinue",
"=",
"append",
"(",
"rulesBucket",
".",
"RejectObserveContinue",
",",
"acls",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"testAccept",
"(",
"rule",
".",
"policy",
")",
"&&",
"testObserveContinue",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"AcceptObserveContinue",
"=",
"append",
"(",
"rulesBucket",
".",
"AcceptObserveContinue",
",",
"acls",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"testAccept",
"(",
"rule",
".",
"policy",
")",
"&&",
"testNotObserved",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"AcceptNotObserved",
"=",
"append",
"(",
"rulesBucket",
".",
"AcceptNotObserved",
",",
"acls",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"testAccept",
"(",
"rule",
".",
"policy",
")",
"&&",
"testObserveApply",
"(",
"rule",
".",
"policy",
")",
"{",
"rulesBucket",
".",
"AcceptObserveApply",
"=",
"append",
"(",
"rulesBucket",
".",
"AcceptObserveApply",
",",
"acls",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"rulesBucket",
"\n",
"}"
] | // 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",
"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",
"."
] | 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",
".",
"sortACLsInBuckets",
"(",
"contextID",
",",
"chain",
",",
"reverseChain",
",",
"rules",
",",
"isAppAcls",
")",
"\n\n",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"acls",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
"rule",
"[",
"]",
"string",
")",
"string",
"{",
"return",
"strings",
".",
"Join",
"(",
"rule",
",",
"\"",
"\"",
")",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"acls",
")",
")",
"\n\n",
"aclRules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"*",
"rulesBucket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"processRulesFromList",
"(",
"aclRules",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"isAppAcls",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
"cfg",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"UID",
"!=",
"\"",
"\"",
"{",
"return",
"i",
".",
"processRulesFromList",
"(",
"i",
".",
"uidChainRules",
"(",
"cfg",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"i",
".",
"processRulesFromList",
"(",
"i",
".",
"cgroupChainRules",
"(",
"cfg",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // 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",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"appChain",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"i",
".",
"appPacketIPTableContext",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"DeleteChain",
"(",
"i",
".",
"appPacketIPTableContext",
",",
"appChain",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"appChain",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"i",
".",
"appPacketIPTableContext",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"ClearChain",
"(",
"i",
".",
"netPacketIPTableContext",
",",
"netChain",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"netChain",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"i",
".",
"netPacketIPTableContext",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"DeleteChain",
"(",
"i",
".",
"netPacketIPTableContext",
",",
"netChain",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"netChain",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"i",
".",
"netPacketIPTableContext",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"}",
"\n\n",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"globalRules",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"i",
".",
"mode",
"==",
"constants",
".",
"LocalServer",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"globalRules",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"processRulesFromList",
"(",
"rules",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// nat rules cannot be templated, since they interfere with Docker.",
"err",
"=",
"i",
".",
"ipt",
".",
"Insert",
"(",
"i",
".",
"appProxyIPTableContext",
",",
"ipTableSectionPreRouting",
",",
"1",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"excludedNetworkSet",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"natProxyInputChain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"i",
".",
"ipt",
".",
"Insert",
"(",
"i",
".",
"appProxyIPTableContext",
",",
"ipTableSectionOutput",
",",
"1",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"excludedNetworkSet",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"natProxyOutputChain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\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",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"context",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"if",
"strings",
".",
"Contains",
"(",
"rule",
",",
"chainPrefix",
")",
"{",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"ClearChain",
"(",
"context",
",",
"rule",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"context",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"rule",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"DeleteChain",
"(",
"context",
",",
"rule",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"context",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"rule",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // 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",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
"return",
"ret0",
"\n",
"}"
] | // 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",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRuntimeReader",
")",
"(",
"nil",
")",
".",
"Tag",
")",
",",
"arg0",
")",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"*",
"policy",
".",
"TagStore",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"policy",
".",
"OptionsType",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"policy",
".",
"ExtendedMap",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"]",
".",
"(",
"common",
".",
"PUType",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"TypeOf",
"(",
"(",
"*",
"MockRuntimeReader",
")",
"(",
"nil",
")",
".",
"PUType",
")",
")",
"\n",
"}"
] | // 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",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRuntimeReader",
")",
"(",
"nil",
")",
".",
"SetServices",
")",
",",
"services",
")",
"\n",
"}"
] | // 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",
"[",
"0",
"]",
".",
"(",
"map",
"[",
"nat",
".",
"Port",
"]",
"[",
"]",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // 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",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"puID",
",",
"event",
",",
"runtime",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // 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",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockResolver",
")",
"(",
"nil",
")",
".",
"HandlePUEvent",
")",
",",
"ctx",
",",
"puID",
",",
"event",
",",
"runtime",
")",
"\n",
"}"
] | // 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",
"collector",
".",
"DatapathVersionMismatch",
"\n",
"default",
":",
"return",
"collector",
".",
"InvalidToken",
"\n",
"}",
"\n",
"}"
] | // 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",
".",
"Code",
"(",
")",
"\n",
"}"
] | // 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",
".",
"ipv4groupSource",
"}",
",",
"64",
",",
"a",
".",
"sourceNFLogsHanlder",
",",
"a",
".",
"nflogErrorHandler",
")",
"\n",
"a",
".",
"dstNflogHandle",
",",
"_",
"=",
"nflog",
".",
"BindAndListenForLogs",
"(",
"[",
"]",
"uint16",
"{",
"a",
".",
"ipv4groupDest",
"}",
",",
"64",
",",
"a",
".",
"destNFLogsHandler",
",",
"a",
".",
"nflogErrorHandler",
")",
"\n",
"a",
".",
"Unlock",
"(",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"a",
".",
"Lock",
"(",
")",
"\n",
"a",
".",
"srcNflogHandle",
".",
"NFlogClose",
"(",
")",
"\n",
"a",
".",
"dstNflogHandle",
".",
"NFlogClose",
"(",
")",
"\n",
"a",
".",
"Unlock",
"(",
")",
"\n\n",
"}",
"(",
")",
"\n",
"}"
] | // 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",
"{",
"sourceIP",
":=",
"\"",
"\"",
"\n",
"sourcePort",
":=",
"0",
"\n",
"if",
"sourceAddress",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"r",
".",
"RemoteAddr",
")",
";",
"err",
"==",
"nil",
"{",
"sourceIP",
"=",
"sourceAddress",
".",
"IP",
".",
"String",
"(",
")",
"\n",
"sourcePort",
"=",
"sourceAddress",
".",
"Port",
"\n",
"}",
"\n\n",
"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",
":",
"\"",
"\"",
",",
"Count",
":",
"1",
",",
"}",
",",
"}",
"\n",
"}"
] | // 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",
"&",
"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",
":",
"\"",
"\"",
",",
"ServiceID",
":",
"pctx",
".",
"Service",
".",
"ID",
",",
"Tags",
":",
"pctx",
".",
"PUContext",
".",
"Annotations",
"(",
")",
",",
"Count",
":",
"1",
",",
"}",
",",
"}",
"\n",
"}"
] | // 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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"runtimeTags",
":=",
"policy",
".",
"NewTagStore",
"(",
")",
"\n",
"for",
"_",
",",
"tag",
":=",
"range",
"event",
".",
"Tags",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"tag",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n",
"runtimeTags",
".",
"AppendKeyValue",
"(",
"\"",
"\"",
"+",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"1",
"]",
")",
"\n",
"}",
"\n\n",
"runtimeIps",
":=",
"policy",
".",
"ExtendedMap",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
"\n\n",
"return",
"policy",
".",
"NewPURuntime",
"(",
"event",
".",
"Name",
",",
"1",
",",
"\"",
"\"",
",",
"runtimeTags",
",",
"runtimeIps",
",",
"common",
".",
"LinuxProcessPU",
",",
"nil",
")",
",",
"nil",
"\n",
"}"
] | // 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",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"ipt",
".",
"CleanUp",
"(",
")",
"\n",
"}"
] | // 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",
"(",
")",
"&&",
"f",
".",
"Rejected",
"(",
")",
"{",
"return",
"actionReject",
"\n",
"}",
"\n\n",
"return",
"actionPassthrough",
"\n",
"}"
] | // 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",
".",
"EncodedActionString",
"(",
")",
"\n",
"return",
"prefix",
"\n",
"}"
] | // 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.