id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,800 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go
|
NewRPCClient
|
func (mr *MockRPCClientMockRecorder) NewRPCClient(contextID, channel, rpcSecret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRPCClient", reflect.TypeOf((*MockRPCClient)(nil).NewRPCClient), contextID, channel, rpcSecret)
}
|
go
|
func (mr *MockRPCClientMockRecorder) NewRPCClient(contextID, channel, rpcSecret interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRPCClient", reflect.TypeOf((*MockRPCClient)(nil).NewRPCClient), contextID, channel, rpcSecret)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"NewRPCClient",
"(",
"contextID",
",",
"channel",
",",
"rpcSecret",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"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.