id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
7,400 | aporeto-inc/trireme-lib | controller/pkg/usertokens/usetokens.go | NewVerifier | func NewVerifier(v Verifier) (Verifier, error) {
if v == nil {
return nil, nil
}
switch v.VerifierType() {
case common.PKI:
p := v.(*pkitokens.PKIJWTVerifier)
v, err := pkitokens.NewVerifier(p)
if err != nil {
return nil, err
}
return v, nil
case common.OIDC:
p := v.(*oidc.TokenVerifier)
verifier, err := oidc.NewClient(context.Background(), p)
if err != nil {
return nil, err
}
return verifier, nil
}
return nil, fmt.Errorf("uknown verifier type")
} | go | func NewVerifier(v Verifier) (Verifier, error) {
if v == nil {
return nil, nil
}
switch v.VerifierType() {
case common.PKI:
p := v.(*pkitokens.PKIJWTVerifier)
v, err := pkitokens.NewVerifier(p)
if err != nil {
return nil, err
}
return v, nil
case common.OIDC:
p := v.(*oidc.TokenVerifier)
verifier, err := oidc.NewClient(context.Background(), p)
if err != nil {
return nil, err
}
return verifier, nil
}
return nil, fmt.Errorf("uknown verifier type")
} | [
"func",
"NewVerifier",
"(",
"v",
"Verifier",
")",
"(",
"Verifier",
",",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"switch",
"v",
".",
"VerifierType",
"(",
")",
"{",
"case",
"common",
".",
"PKI",
... | // NewVerifier initializes data structures based on the interface that
// is transmitted over the RPC between main and remote enforcers. | [
"NewVerifier",
"initializes",
"data",
"structures",
"based",
"on",
"the",
"interface",
"that",
"is",
"transmitted",
"over",
"the",
"RPC",
"between",
"main",
"and",
"remote",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/usertokens/usetokens.go#L26-L47 |
7,401 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | NewMockEnforcer | func NewMockEnforcer(ctrl *gomock.Controller) *MockEnforcer {
mock := &MockEnforcer{ctrl: ctrl}
mock.recorder = &MockEnforcerMockRecorder{mock}
return mock
} | go | func NewMockEnforcer(ctrl *gomock.Controller) *MockEnforcer {
mock := &MockEnforcer{ctrl: ctrl}
mock.recorder = &MockEnforcerMockRecorder{mock}
return mock
} | [
"func",
"NewMockEnforcer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEnforcer",
"{",
"mock",
":=",
"&",
"MockEnforcer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEnforcerMockRecorder",
"{",
"mock",
"}"... | // NewMockEnforcer creates a new mock instance
// nolint | [
"NewMockEnforcer",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L35-L39 |
7,402 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | Unenforce | func (m *MockEnforcer) Unenforce(contextID string) error {
ret := m.ctrl.Call(m, "Unenforce", contextID)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockEnforcer) Unenforce(contextID string) error {
ret := m.ctrl.Call(m, "Unenforce", contextID)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"Unenforce",
"(",
"contextID",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
... | // Unenforce mocks base method
// nolint | [
"Unenforce",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L63-L67 |
7,403 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | GetFilterQueue | func (m *MockEnforcer) GetFilterQueue() *fqconfig.FilterQueue {
ret := m.ctrl.Call(m, "GetFilterQueue")
ret0, _ := ret[0].(*fqconfig.FilterQueue)
return ret0
} | go | func (m *MockEnforcer) GetFilterQueue() *fqconfig.FilterQueue {
ret := m.ctrl.Call(m, "GetFilterQueue")
ret0, _ := ret[0].(*fqconfig.FilterQueue)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"GetFilterQueue",
"(",
")",
"*",
"fqconfig",
".",
"FilterQueue",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".... | // GetFilterQueue mocks base method
// nolint | [
"GetFilterQueue",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L77-L81 |
7,404 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | GetFilterQueue | func (mr *MockEnforcerMockRecorder) GetFilterQueue() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilterQueue", reflect.TypeOf((*MockEnforcer)(nil).GetFilterQueue))
} | go | func (mr *MockEnforcerMockRecorder) GetFilterQueue() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilterQueue", reflect.TypeOf((*MockEnforcer)(nil).GetFilterQueue))
} | [
"func",
"(",
"mr",
"*",
"MockEnforcerMockRecorder",
")",
"GetFilterQueue",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",... | // GetFilterQueue indicates an expected call of GetFilterQueue
// nolint | [
"GetFilterQueue",
"indicates",
"an",
"expected",
"call",
"of",
"GetFilterQueue",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L85-L87 |
7,405 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | CleanUp | func (m *MockEnforcer) CleanUp() error {
ret := m.ctrl.Call(m, "CleanUp")
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockEnforcer) CleanUp() error {
ret := m.ctrl.Call(m, "CleanUp")
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"CleanUp",
"(",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"re... | // CleanUp mocks base method
// nolint | [
"CleanUp",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L133-L137 |
7,406 | aporeto-inc/trireme-lib | controller/internal/enforcer/mockenforcer/mockenforcer.go | EnableIPTablesPacketTracing | func (m *MockDebugInfo) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
ret := m.ctrl.Call(m, "EnableIPTablesPacketTracing", ctx, contextID, interval)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockDebugInfo) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
ret := m.ctrl.Call(m, "EnableIPTablesPacketTracing", ctx, contextID, interval)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockDebugInfo",
")",
"EnableIPTablesPacketTracing",
"(",
"ctx",
"context",
".",
"Context",
",",
"contextID",
"string",
",",
"interval",
"time",
".",
"Duration",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"... | // EnableIPTablesPacketTracing mocks base method
// nolint | [
"EnableIPTablesPacketTracing",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L216-L220 |
7,407 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | GetUDPData | func (p *Packet) GetUDPData() []byte {
return p.ipHdr.Buffer[p.ipHdr.ipHeaderLen+UDPDataPos:]
} | go | func (p *Packet) GetUDPData() []byte {
return p.ipHdr.Buffer[p.ipHdr.ipHeaderLen+UDPDataPos:]
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"GetUDPData",
"(",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
"+",
"UDPDataPos",
":",
"]",
"\n",
"}"
] | // GetUDPData return additional data in packet | [
"GetUDPData",
"return",
"additional",
"data",
"in",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L143-L145 |
7,408 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | DropTCPDetachedBytes | func (p *Packet) DropTCPDetachedBytes() {
p.tcpHdr.tcpOptions = []byte{}
p.tcpHdr.tcpData = []byte{}
} | go | func (p *Packet) DropTCPDetachedBytes() {
p.tcpHdr.tcpOptions = []byte{}
p.tcpHdr.tcpData = []byte{}
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"DropTCPDetachedBytes",
"(",
")",
"{",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpData",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}"
] | // DropTCPDetachedBytes removes any bytes that have been detached and stored locally | [
"DropTCPDetachedBytes",
"removes",
"any",
"bytes",
"that",
"have",
"been",
"detached",
"and",
"stored",
"locally"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L168-L172 |
7,409 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | Print | func (p *Packet) Print(context uint64) {
if p.ipHdr.ipProto != IPProtocolTCP {
return
}
logPkt := false
detailed := false
if PacketLogLevel || context == 0 {
logPkt = true
detailed = true
}
var buf string
print := false
if logPkt {
if printCount%200 == 0 {
buf += fmt.Sprintf("Packet: %5s %5s %25s %15s %5s %15s %5s %6s %20s %20s %6s %20s %20s %2s %5s %5s\n",
"IPID", "Dir", "Comment", "SIP", "SP", "DIP", "DP", "Flags", "TCPSeq", "TCPAck", "TCPLen", "ExpAck", "ExpSeq", "DO", "Acsum", "Ccsum")
}
printCount++
offset := 0
if (p.GetTCPFlags() & TCPSynMask) == TCPSynMask {
offset = 1
}
expAck := p.tcpHdr.tcpSeq + uint32(uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes()) + uint32(offset)
ccsum := p.computeTCPChecksum()
csumValidationStr := ""
if p.tcpHdr.tcpChecksum != ccsum {
csumValidationStr = "Bad Checksum"
}
buf += fmt.Sprintf("Packet: %5d %5s %25s %15s %5d %15s %5d %6s %20d %20d %6d %20d %20d %2d %5d %5d %12s\n",
p.ipHdr.ipID,
flagsToDir(p.context|context),
flagsToStr(p.context|context),
p.ipHdr.sourceAddress.To4().String(), p.tcpHdr.sourcePort,
p.ipHdr.destinationAddress.To4().String(), p.tcpHdr.destinationPort,
tcpFlagsToStr(p.GetTCPFlags()),
p.tcpHdr.tcpSeq, p.tcpHdr.tcpAck, uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes(),
expAck, expAck, p.tcpHdr.tcpDataOffset,
p.tcpHdr.tcpChecksum, ccsum, csumValidationStr)
print = true
}
if detailed {
pktBytes := []byte{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 8, 0}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
buf += fmt.Sprintf("%s\n", hex.Dump(pktBytes))
print = true
}
if print {
zap.L().Debug(buf)
}
} | go | func (p *Packet) Print(context uint64) {
if p.ipHdr.ipProto != IPProtocolTCP {
return
}
logPkt := false
detailed := false
if PacketLogLevel || context == 0 {
logPkt = true
detailed = true
}
var buf string
print := false
if logPkt {
if printCount%200 == 0 {
buf += fmt.Sprintf("Packet: %5s %5s %25s %15s %5s %15s %5s %6s %20s %20s %6s %20s %20s %2s %5s %5s\n",
"IPID", "Dir", "Comment", "SIP", "SP", "DIP", "DP", "Flags", "TCPSeq", "TCPAck", "TCPLen", "ExpAck", "ExpSeq", "DO", "Acsum", "Ccsum")
}
printCount++
offset := 0
if (p.GetTCPFlags() & TCPSynMask) == TCPSynMask {
offset = 1
}
expAck := p.tcpHdr.tcpSeq + uint32(uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes()) + uint32(offset)
ccsum := p.computeTCPChecksum()
csumValidationStr := ""
if p.tcpHdr.tcpChecksum != ccsum {
csumValidationStr = "Bad Checksum"
}
buf += fmt.Sprintf("Packet: %5d %5s %25s %15s %5d %15s %5d %6s %20d %20d %6d %20d %20d %2d %5d %5d %12s\n",
p.ipHdr.ipID,
flagsToDir(p.context|context),
flagsToStr(p.context|context),
p.ipHdr.sourceAddress.To4().String(), p.tcpHdr.sourcePort,
p.ipHdr.destinationAddress.To4().String(), p.tcpHdr.destinationPort,
tcpFlagsToStr(p.GetTCPFlags()),
p.tcpHdr.tcpSeq, p.tcpHdr.tcpAck, uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes(),
expAck, expAck, p.tcpHdr.tcpDataOffset,
p.tcpHdr.tcpChecksum, ccsum, csumValidationStr)
print = true
}
if detailed {
pktBytes := []byte{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 8, 0}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
buf += fmt.Sprintf("%s\n", hex.Dump(pktBytes))
print = true
}
if print {
zap.L().Debug(buf)
}
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"Print",
"(",
"context",
"uint64",
")",
"{",
"if",
"p",
".",
"ipHdr",
".",
"ipProto",
"!=",
"IPProtocolTCP",
"{",
"return",
"\n",
"}",
"\n\n",
"logPkt",
":=",
"false",
"\n",
"detailed",
":=",
"false",
"\n\n",
"if... | // Print is a print helper function | [
"Print",
"is",
"a",
"print",
"helper",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L185-L247 |
7,410 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | GetTCPBytes | func (p *Packet) GetTCPBytes() []byte {
pktBytes := []byte{}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
return pktBytes
} | go | func (p *Packet) GetTCPBytes() []byte {
pktBytes := []byte{}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
return pktBytes
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"GetTCPBytes",
"(",
")",
"[",
"]",
"byte",
"{",
"pktBytes",
":=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"ipHdr",
".",
"Buffer",
"...",
")",
"\n",
"pktByt... | //GetTCPBytes returns the bytes in the packet. It consolidates in case of changes as well | [
"GetTCPBytes",
"returns",
"the",
"bytes",
"in",
"the",
"packet",
".",
"It",
"consolidates",
"in",
"case",
"of",
"changes",
"as",
"well"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L250-L257 |
7,411 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | ReadTCPData | func (p *Packet) ReadTCPData() []byte {
return p.ipHdr.Buffer[uint16(p.ipHdr.ipHeaderLen)+p.TCPDataStartBytes():]
} | go | func (p *Packet) ReadTCPData() []byte {
return p.ipHdr.Buffer[uint16(p.ipHdr.ipHeaderLen)+p.TCPDataStartBytes():]
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"ReadTCPData",
"(",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"uint16",
"(",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
")",
"+",
"p",
".",
"TCPDataStartBytes",
"(",
")",
":",
"... | // ReadTCPData returns ths payload in a string variable
// It does not remove the payload from the packet | [
"ReadTCPData",
"returns",
"ths",
"payload",
"in",
"a",
"string",
"variable",
"It",
"does",
"not",
"remove",
"the",
"payload",
"from",
"the",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L267-L269 |
7,412 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | CheckTCPAuthenticationOption | func (p *Packet) CheckTCPAuthenticationOption(iOptionLength int) (err error) {
tcpDataStart := p.TCPDataStartBytes()
if tcpDataStart <= minTCPIPPacketLen {
return errTCPAuthOption
}
optionLength := uint16(iOptionLength)
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// Our option was not found in the right place. We don't do anything
// for this packet.
if buffer[tcpDataStart-optionLength] != TCPAuthenticationOption {
return errTCPAuthOption
}
return
} | go | func (p *Packet) CheckTCPAuthenticationOption(iOptionLength int) (err error) {
tcpDataStart := p.TCPDataStartBytes()
if tcpDataStart <= minTCPIPPacketLen {
return errTCPAuthOption
}
optionLength := uint16(iOptionLength)
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// Our option was not found in the right place. We don't do anything
// for this packet.
if buffer[tcpDataStart-optionLength] != TCPAuthenticationOption {
return errTCPAuthOption
}
return
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"CheckTCPAuthenticationOption",
"(",
"iOptionLength",
"int",
")",
"(",
"err",
"error",
")",
"{",
"tcpDataStart",
":=",
"p",
".",
"TCPDataStartBytes",
"(",
")",
"\n\n",
"if",
"tcpDataStart",
"<=",
"minTCPIPPacketLen",
"{",
... | // CheckTCPAuthenticationOption ensures authentication option exists at the offset provided | [
"CheckTCPAuthenticationOption",
"ensures",
"authentication",
"option",
"exists",
"at",
"the",
"offset",
"provided"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L272-L289 |
7,413 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | FixupIPHdrOnDataModify | func (p *Packet) FixupIPHdrOnDataModify(old, new uint16) {
// IP Header Processing
// IP chekcsum fixup.
p.ipHdr.ipChecksum = incCsum16(p.ipHdr.ipChecksum, old, new)
// Update IP Total Length.
p.ipHdr.ipTotalLength = p.ipHdr.ipTotalLength + new - old
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4LengthPos:ipv4LengthPos+2], p.ipHdr.ipTotalLength)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | go | func (p *Packet) FixupIPHdrOnDataModify(old, new uint16) {
// IP Header Processing
// IP chekcsum fixup.
p.ipHdr.ipChecksum = incCsum16(p.ipHdr.ipChecksum, old, new)
// Update IP Total Length.
p.ipHdr.ipTotalLength = p.ipHdr.ipTotalLength + new - old
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4LengthPos:ipv4LengthPos+2], p.ipHdr.ipTotalLength)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"FixupIPHdrOnDataModify",
"(",
"old",
",",
"new",
"uint16",
")",
"{",
"// IP Header Processing",
"// IP chekcsum fixup.",
"p",
".",
"ipHdr",
".",
"ipChecksum",
"=",
"incCsum16",
"(",
"p",
".",
"ipHdr",
".",
"ipChecksum",
... | // FixupIPHdrOnDataModify modifies the IP header fields and checksum | [
"FixupIPHdrOnDataModify",
"modifies",
"the",
"IP",
"header",
"fields",
"and",
"checksum"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L292-L301 |
7,414 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | IncreaseTCPSeq | func (p *Packet) IncreaseTCPSeq(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq + incr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
} | go | func (p *Packet) IncreaseTCPSeq(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq + incr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"IncreaseTCPSeq",
"(",
"incr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"=",
"p",
".... | // IncreaseTCPSeq increases TCP seq number by incr | [
"IncreaseTCPSeq",
"increases",
"TCP",
"seq",
"number",
"by",
"incr"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L304-L308 |
7,415 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | DecreaseTCPSeq | func (p *Packet) DecreaseTCPSeq(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq - decr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
} | go | func (p *Packet) DecreaseTCPSeq(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq - decr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"DecreaseTCPSeq",
"(",
"decr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"=",
"p",
".... | // DecreaseTCPSeq decreases TCP seq number by decr | [
"DecreaseTCPSeq",
"decreases",
"TCP",
"seq",
"number",
"by",
"decr"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L311-L315 |
7,416 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | IncreaseTCPAck | func (p *Packet) IncreaseTCPAck(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck + incr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
} | go | func (p *Packet) IncreaseTCPAck(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck + incr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"IncreaseTCPAck",
"(",
"incr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"=",
"p",
".... | // IncreaseTCPAck increases TCP ack number by incr | [
"IncreaseTCPAck",
"increases",
"TCP",
"ack",
"number",
"by",
"incr"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L318-L322 |
7,417 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | DecreaseTCPAck | func (p *Packet) DecreaseTCPAck(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck - decr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
} | go | func (p *Packet) DecreaseTCPAck(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck - decr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"DecreaseTCPAck",
"(",
"decr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"=",
"p",
".... | // DecreaseTCPAck decreases TCP ack number by decr | [
"DecreaseTCPAck",
"decreases",
"TCP",
"ack",
"number",
"by",
"decr"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L325-L329 |
7,418 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | FixuptcpHdrOnTCPDataDetach | func (p *Packet) FixuptcpHdrOnTCPDataDetach(dataLength uint16, optionLength uint16) {
// Update DataOffset
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset - uint8(optionLength/4)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
} | go | func (p *Packet) FixuptcpHdrOnTCPDataDetach(dataLength uint16, optionLength uint16) {
// Update DataOffset
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset - uint8(optionLength/4)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"FixuptcpHdrOnTCPDataDetach",
"(",
"dataLength",
"uint16",
",",
"optionLength",
"uint16",
")",
"{",
"// Update DataOffset",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":... | // FixuptcpHdrOnTCPDataDetach modifies the TCP header fields and checksum | [
"FixuptcpHdrOnTCPDataDetach",
"modifies",
"the",
"TCP",
"header",
"fields",
"and",
"checksum"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L332-L338 |
7,419 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | FixuptcpHdrOnTCPDataAttach | func (p *Packet) FixuptcpHdrOnTCPDataAttach(tcpOptions []byte, tcpData []byte) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
numberOfOptions := len(tcpOptions) / 4
// Modify the fields
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset + uint8(numberOfOptions)
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
} | go | func (p *Packet) FixuptcpHdrOnTCPDataAttach(tcpOptions []byte, tcpData []byte) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
numberOfOptions := len(tcpOptions) / 4
// Modify the fields
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset + uint8(numberOfOptions)
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"FixuptcpHdrOnTCPDataAttach",
"(",
"tcpOptions",
"[",
"]",
"byte",
",",
"tcpData",
"[",
"]",
"byte",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]... | // FixuptcpHdrOnTCPDataAttach modifies the TCP header fields and checksum | [
"FixuptcpHdrOnTCPDataAttach",
"modifies",
"the",
"TCP",
"header",
"fields",
"and",
"checksum"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L382-L390 |
7,420 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | TCPDataAttach | func (p *Packet) TCPDataAttach(tcpOptions []byte, tcpData []byte) (err error) {
if err = p.tcpDataAttach(tcpOptions, tcpData); err != nil {
return fmt.Errorf("tcp data attachment failed: %s", err)
}
// We are increasing tcpOptions by 1 32-bit word. We are always adding
// our option last.
packetLenIncrease := uint16(len(tcpData) + len(tcpOptions))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// TCP Header Processing
p.FixuptcpHdrOnTCPDataAttach(tcpOptions, tcpData)
return
} | go | func (p *Packet) TCPDataAttach(tcpOptions []byte, tcpData []byte) (err error) {
if err = p.tcpDataAttach(tcpOptions, tcpData); err != nil {
return fmt.Errorf("tcp data attachment failed: %s", err)
}
// We are increasing tcpOptions by 1 32-bit word. We are always adding
// our option last.
packetLenIncrease := uint16(len(tcpData) + len(tcpOptions))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// TCP Header Processing
p.FixuptcpHdrOnTCPDataAttach(tcpOptions, tcpData)
return
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"TCPDataAttach",
"(",
"tcpOptions",
"[",
"]",
"byte",
",",
"tcpData",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"p",
".",
"tcpDataAttach",
"(",
"tcpOptions",
",",
"tcpData",
")",
"... | // TCPDataAttach modifies the TCP and IP header fields and checksum | [
"TCPDataAttach",
"modifies",
"the",
"TCP",
"and",
"IP",
"header",
"fields",
"and",
"checksum"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L406-L422 |
7,421 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | L4FlowHash | func (p *Packet) L4FlowHash() string {
return p.ipHdr.sourceAddress.String() + ":" + p.ipHdr.destinationAddress.String() + ":" + strconv.Itoa(int(p.SourcePort())) + ":" + strconv.Itoa(int(p.DestPort()))
} | go | func (p *Packet) L4FlowHash() string {
return p.ipHdr.sourceAddress.String() + ":" + p.ipHdr.destinationAddress.String() + ":" + strconv.Itoa(int(p.SourcePort())) + ":" + strconv.Itoa(int(p.DestPort()))
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"L4FlowHash",
"(",
")",
"string",
"{",
"return",
"p",
".",
"ipHdr",
".",
"sourceAddress",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"p",
".",
"ipHdr",
".",
"destinationAddress",
".",
"String",
"(",
")",
"+... | // L4FlowHash calculate a hash string based on the 4-tuple | [
"L4FlowHash",
"calculate",
"a",
"hash",
"string",
"based",
"on",
"the",
"4",
"-",
"tuple"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L425-L427 |
7,422 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | ID | func (p *Packet) ID() string {
return strconv.Itoa(int(p.ipHdr.ipID))
} | go | func (p *Packet) ID() string {
return strconv.Itoa(int(p.ipHdr.ipID))
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"ID",
"(",
")",
"string",
"{",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"ipHdr",
".",
"ipID",
")",
")",
"\n",
"}"
] | // ID returns the IP ID of the packet | [
"ID",
"returns",
"the",
"IP",
"ID",
"of",
"the",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L444-L446 |
7,423 | aporeto-inc/trireme-lib | controller/pkg/packet/packet.go | GetBuffer | func (p *Packet) GetBuffer(offset int) []byte {
return p.ipHdr.Buffer[offset:]
} | go | func (p *Packet) GetBuffer(offset int) []byte {
return p.ipHdr.Buffer[offset:]
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"GetBuffer",
"(",
"offset",
"int",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"offset",
":",
"]",
"\n",
"}"
] | //GetBuffer returns the slice representing the buffer at offset specified | [
"GetBuffer",
"returns",
"the",
"slice",
"representing",
"the",
"buffer",
"at",
"offset",
"specified"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L502-L504 |
7,424 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | NewInstance | func NewInstance(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration) (*Instance, error) {
ipt, err := provider.NewGoIPTablesProvider([]string{"mangle"})
if err != nil {
return nil, fmt.Errorf("unable to initialize iptables provider: %s", err)
}
ips := provider.NewGoIPsetProvider()
return newInstanceWithProviders(fqc, mode, cfg, ipt, ips)
} | go | func NewInstance(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration) (*Instance, error) {
ipt, err := provider.NewGoIPTablesProvider([]string{"mangle"})
if err != nil {
return nil, fmt.Errorf("unable to initialize iptables provider: %s", err)
}
ips := provider.NewGoIPsetProvider()
return newInstanceWithProviders(fqc, mode, cfg, ipt, ips)
} | [
"func",
"NewInstance",
"(",
"fqc",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"mode",
"constants",
".",
"ModeType",
",",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"(",
"*",
"Instance",
",",
"error",
")",
"{",
"ipt",
",",
"err",
":=",
"provider",
... | // NewInstance creates a new iptables controller instance | [
"NewInstance",
"creates",
"a",
"new",
"iptables",
"controller",
"instance"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L105-L114 |
7,425 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | newInstanceWithProviders | func newInstanceWithProviders(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration, ipt provider.IptablesProvider, ips provider.IpsetProvider) (*Instance, error) {
if cfg == nil {
cfg = &runtime.Configuration{}
}
i := &Instance{
fqc: fqc,
ipt: ipt,
ipset: ips,
appPacketIPTableContext: "mangle",
netPacketIPTableContext: "mangle",
appProxyIPTableContext: "nat",
mode: mode,
appPacketIPTableSection: ipTableSectionOutput,
appCgroupIPTableSection: TriremeOutput,
netLinuxIPTableSection: TriremeInput,
netPacketIPTableSection: ipTableSectionInput,
appSynAckIPTableSection: ipTableSectionOutput,
contextIDToPortSetMap: cache.NewCache("contextIDToPortSetMap"),
createPUPortSet: ipsetCreatePortset,
isLegacyKernel: buildflags.IsLegacyKernel(),
serviceIDToIPsets: map[string]*ipsetInfo{},
puToServiceIDs: map[string][]string{},
cfg: cfg,
conntrackCmd: flushUDPConntrack,
}
lock.Lock()
instance = i
defer lock.Unlock()
return i, nil
} | go | func newInstanceWithProviders(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration, ipt provider.IptablesProvider, ips provider.IpsetProvider) (*Instance, error) {
if cfg == nil {
cfg = &runtime.Configuration{}
}
i := &Instance{
fqc: fqc,
ipt: ipt,
ipset: ips,
appPacketIPTableContext: "mangle",
netPacketIPTableContext: "mangle",
appProxyIPTableContext: "nat",
mode: mode,
appPacketIPTableSection: ipTableSectionOutput,
appCgroupIPTableSection: TriremeOutput,
netLinuxIPTableSection: TriremeInput,
netPacketIPTableSection: ipTableSectionInput,
appSynAckIPTableSection: ipTableSectionOutput,
contextIDToPortSetMap: cache.NewCache("contextIDToPortSetMap"),
createPUPortSet: ipsetCreatePortset,
isLegacyKernel: buildflags.IsLegacyKernel(),
serviceIDToIPsets: map[string]*ipsetInfo{},
puToServiceIDs: map[string][]string{},
cfg: cfg,
conntrackCmd: flushUDPConntrack,
}
lock.Lock()
instance = i
defer lock.Unlock()
return i, nil
} | [
"func",
"newInstanceWithProviders",
"(",
"fqc",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"mode",
"constants",
".",
"ModeType",
",",
"cfg",
"*",
"runtime",
".",
"Configuration",
",",
"ipt",
"provider",
".",
"IptablesProvider",
",",
"ips",
"provider",
".",
"Ips... | // newInstanceWithProviders is called after ipt and ips have been created. This helps
// with all the unit testing to be able to mock the providers. | [
"newInstanceWithProviders",
"is",
"called",
"after",
"ipt",
"and",
"ips",
"have",
"been",
"created",
".",
"This",
"helps",
"with",
"all",
"the",
"unit",
"testing",
"to",
"be",
"able",
"to",
"mock",
"the",
"providers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L118-L151 |
7,426 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | Run | func (i *Instance) Run(ctx context.Context) error {
go func() {
<-ctx.Done()
zap.L().Debug("Stop the supervisor")
i.CleanUp() // nolint
}()
// Clean any previous ACLs. This is needed in case we crashed at some
// earlier point or there are other ACLs that create conflicts. We
// try to clean only ACLs related to Trireme.
if err := i.cleanACLs(); err != nil {
return fmt.Errorf("Unable to clean previous acls while starting the supervisor: %s", err)
}
// Create all the basic target sets. These are the global target sets
// that do not depend on policy configuration. If they already exist
// we will delete them and start again.
targetTCPSet, targetUDPSet, excludedSet, err := createGlobalSets(i.ipset)
if err != nil {
return fmt.Errorf("unable to create global sets: %s", err)
}
i.targetTCPSet = targetTCPSet
i.targetUDPSet = targetUDPSet
i.excludedNetworksSet = excludedSet
if err := i.updateAllTargetNetworks(i.cfg, &runtime.Configuration{}); err != nil {
// If there is a failure try to clean up on exit.
i.ipset.DestroyAll(chainPrefix) // nolint errcheck
return fmt.Errorf("unable to initialize target networks: %s", err)
}
// Initialize all the global Trireme chains. There are several global chaims
// that apply to all PUs:
// Tri-App/Tri-Net are the main chains for the egress/ingress directions
// UID related chains for any UID PUs.
// Host, Service, Pid chains for the different modes of operation (host mode, pu mode, host service).
// The priority is explicit (Pid activations take precedence of Service activations and Host Services)
if err := i.initializeChains(); err != nil {
return fmt.Errorf("Unable to initialize chains: %s", err)
}
// Insert the global ACLS. These are the main ACLs that will direct traffic from
// the INPUT/OUTPUT chains to the Trireme chains. They also includes the main
// rules of the main chains. These rules are never touched again, unless
// if we gracefully terminate.
if err := i.setGlobalRules(); err != nil {
return fmt.Errorf("failed to update synack networks: %s", err)
}
return nil
} | go | func (i *Instance) Run(ctx context.Context) error {
go func() {
<-ctx.Done()
zap.L().Debug("Stop the supervisor")
i.CleanUp() // nolint
}()
// Clean any previous ACLs. This is needed in case we crashed at some
// earlier point or there are other ACLs that create conflicts. We
// try to clean only ACLs related to Trireme.
if err := i.cleanACLs(); err != nil {
return fmt.Errorf("Unable to clean previous acls while starting the supervisor: %s", err)
}
// Create all the basic target sets. These are the global target sets
// that do not depend on policy configuration. If they already exist
// we will delete them and start again.
targetTCPSet, targetUDPSet, excludedSet, err := createGlobalSets(i.ipset)
if err != nil {
return fmt.Errorf("unable to create global sets: %s", err)
}
i.targetTCPSet = targetTCPSet
i.targetUDPSet = targetUDPSet
i.excludedNetworksSet = excludedSet
if err := i.updateAllTargetNetworks(i.cfg, &runtime.Configuration{}); err != nil {
// If there is a failure try to clean up on exit.
i.ipset.DestroyAll(chainPrefix) // nolint errcheck
return fmt.Errorf("unable to initialize target networks: %s", err)
}
// Initialize all the global Trireme chains. There are several global chaims
// that apply to all PUs:
// Tri-App/Tri-Net are the main chains for the egress/ingress directions
// UID related chains for any UID PUs.
// Host, Service, Pid chains for the different modes of operation (host mode, pu mode, host service).
// The priority is explicit (Pid activations take precedence of Service activations and Host Services)
if err := i.initializeChains(); err != nil {
return fmt.Errorf("Unable to initialize chains: %s", err)
}
// Insert the global ACLS. These are the main ACLs that will direct traffic from
// the INPUT/OUTPUT chains to the Trireme chains. They also includes the main
// rules of the main chains. These rules are never touched again, unless
// if we gracefully terminate.
if err := i.setGlobalRules(); err != nil {
return fmt.Errorf("failed to update synack networks: %s", err)
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"... | // Run starts the iptables controller | [
"Run",
"starts",
"the",
"iptables",
"controller"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L154-L207 |
7,427 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | ConfigureRules | func (i *Instance) ConfigureRules(version int, contextID string, pu *policy.PUInfo) error {
var err error
var cfg *ACLInfo
// First we create an IPSet for destination matching ports. This only
// applies to Linux type PUs. A port set is associated with every PU,
// and packets matching this destination get associated with the context
// of the PU.
if err = i.createPortSet(contextID, pu); err != nil {
return err
}
// We create the generic ACL object that is used for all the templates.
cfg, err = i.newACLInfo(version, contextID, pu, pu.Runtime.PUType())
if err != nil {
return err
}
// Create the proxy sets. These are the target sets that will match
// traffic towards the L4 and L4 services. There are two sets created
// for every PU in this context (for outgoing and incoming traffic).
// The outgoing sets capture all traffic towards specific destinations
// as proxied traffic. Incoming sets correspond to the listening
// services.
if err = i.createProxySets(cfg.ProxySetName); err != nil {
return err
}
// At this point we can install all the ACL rules that will direct
// traffic to user space, allow for external access or direct
// traffic towards the proxies
if err = i.installRules(cfg, pu); err != nil {
return err
}
// We commit the ACLs at the end. Note, that some of the ACLs in the
// NAT table are not committed as a group. The commit function only
// applies when newer versions of tables are installed (1.6.2 and above).
if err = i.ipt.Commit(); err != nil {
zap.L().Error("unable to configure rules", zap.Error(err))
return err
}
i.conntrackCmd(i.cfg.UDPTargetNetworks)
return nil
} | go | func (i *Instance) ConfigureRules(version int, contextID string, pu *policy.PUInfo) error {
var err error
var cfg *ACLInfo
// First we create an IPSet for destination matching ports. This only
// applies to Linux type PUs. A port set is associated with every PU,
// and packets matching this destination get associated with the context
// of the PU.
if err = i.createPortSet(contextID, pu); err != nil {
return err
}
// We create the generic ACL object that is used for all the templates.
cfg, err = i.newACLInfo(version, contextID, pu, pu.Runtime.PUType())
if err != nil {
return err
}
// Create the proxy sets. These are the target sets that will match
// traffic towards the L4 and L4 services. There are two sets created
// for every PU in this context (for outgoing and incoming traffic).
// The outgoing sets capture all traffic towards specific destinations
// as proxied traffic. Incoming sets correspond to the listening
// services.
if err = i.createProxySets(cfg.ProxySetName); err != nil {
return err
}
// At this point we can install all the ACL rules that will direct
// traffic to user space, allow for external access or direct
// traffic towards the proxies
if err = i.installRules(cfg, pu); err != nil {
return err
}
// We commit the ACLs at the end. Note, that some of the ACLs in the
// NAT table are not committed as a group. The commit function only
// applies when newer versions of tables are installed (1.6.2 and above).
if err = i.ipt.Commit(); err != nil {
zap.L().Error("unable to configure rules", zap.Error(err))
return err
}
i.conntrackCmd(i.cfg.UDPTargetNetworks)
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"ConfigureRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"pu",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"cfg",
"*",
"ACLInfo",
"\n\n",
"// First we creat... | // ConfigureRules implments the ConfigureRules interface. It will create the
// port sets and then it will call install rules to create all the ACLs for
// the given chains. PortSets are only created here. Updates will use the
// exact same logic. | [
"ConfigureRules",
"implments",
"the",
"ConfigureRules",
"interface",
".",
"It",
"will",
"create",
"the",
"port",
"sets",
"and",
"then",
"it",
"will",
"call",
"install",
"rules",
"to",
"create",
"all",
"the",
"ACLs",
"for",
"the",
"given",
"chains",
".",
"Por... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L213-L260 |
7,428 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | DeleteRules | func (i *Instance) DeleteRules(version int, contextID string, tcpPorts, udpPorts string, mark string, username string, proxyPort string, puType common.PUType) error {
cfg, err := i.newACLInfo(version, contextID, nil, puType)
if err != nil {
zap.L().Error("unable to create cleanup configuration", zap.Error(err))
return err
}
cfg.UDPPorts = udpPorts
cfg.TCPPorts = tcpPorts
cfg.CgroupMark = mark
cfg.Mark = mark
cfg.UID = username
cfg.PUType = puType
cfg.ProxyPort = proxyPort
// We clean up the chain rules first, so that we can delete the chains.
// If any rule is not deleted, then the chain will show as busy.
if err := i.deleteChainRules(cfg); err != nil {
zap.L().Warn("Failed to clean rules", zap.Error(err))
}
// We can now delete the chains we have created for this PU. Note that
// in every case we only create two chains for every PU. All other
// chains are global.
if err = i.deletePUChains(cfg.AppChain, cfg.NetChain); err != nil {
zap.L().Warn("Failed to clean container chains while deleting the rules", zap.Error(err))
}
// We call commit to update all the changes, before destroying the ipsets.
// References must be deleted for ipset deletion to succeed.
if err := i.ipt.Commit(); err != nil {
zap.L().Warn("Failed to commit ACL changes", zap.Error(err))
}
// We delete the set that captures all destination ports of the
// PU. This only holds for Linux PUs.
if err := i.deletePortSet(contextID); err != nil {
zap.L().Warn("Failed to remove port set")
}
// We delete the proxy port sets that were created for this PU.
if err := i.deleteProxySets(cfg.ProxySetName); err != nil {
zap.L().Warn("Failed to delete proxy sets", zap.Error(err))
}
// Destroy all the ACL related IPSets that were created
// on demand for any external services.
i.destroyACLIPsets(contextID)
return nil
} | go | func (i *Instance) DeleteRules(version int, contextID string, tcpPorts, udpPorts string, mark string, username string, proxyPort string, puType common.PUType) error {
cfg, err := i.newACLInfo(version, contextID, nil, puType)
if err != nil {
zap.L().Error("unable to create cleanup configuration", zap.Error(err))
return err
}
cfg.UDPPorts = udpPorts
cfg.TCPPorts = tcpPorts
cfg.CgroupMark = mark
cfg.Mark = mark
cfg.UID = username
cfg.PUType = puType
cfg.ProxyPort = proxyPort
// We clean up the chain rules first, so that we can delete the chains.
// If any rule is not deleted, then the chain will show as busy.
if err := i.deleteChainRules(cfg); err != nil {
zap.L().Warn("Failed to clean rules", zap.Error(err))
}
// We can now delete the chains we have created for this PU. Note that
// in every case we only create two chains for every PU. All other
// chains are global.
if err = i.deletePUChains(cfg.AppChain, cfg.NetChain); err != nil {
zap.L().Warn("Failed to clean container chains while deleting the rules", zap.Error(err))
}
// We call commit to update all the changes, before destroying the ipsets.
// References must be deleted for ipset deletion to succeed.
if err := i.ipt.Commit(); err != nil {
zap.L().Warn("Failed to commit ACL changes", zap.Error(err))
}
// We delete the set that captures all destination ports of the
// PU. This only holds for Linux PUs.
if err := i.deletePortSet(contextID); err != nil {
zap.L().Warn("Failed to remove port set")
}
// We delete the proxy port sets that were created for this PU.
if err := i.deleteProxySets(cfg.ProxySetName); err != nil {
zap.L().Warn("Failed to delete proxy sets", zap.Error(err))
}
// Destroy all the ACL related IPSets that were created
// on demand for any external services.
i.destroyACLIPsets(contextID)
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"DeleteRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"tcpPorts",
",",
"udpPorts",
"string",
",",
"mark",
"string",
",",
"username",
"string",
",",
"proxyPort",
"string",
",",
"puType",
"common",
"."... | // DeleteRules implements the DeleteRules interface. This is responsible
// for cleaning all ACLs and associated chains, as well as ll the sets
// that we have created. Note, that this only clears up the state
// for a given processing unit. | [
"DeleteRules",
"implements",
"the",
"DeleteRules",
"interface",
".",
"This",
"is",
"responsible",
"for",
"cleaning",
"all",
"ACLs",
"and",
"associated",
"chains",
"as",
"well",
"as",
"ll",
"the",
"sets",
"that",
"we",
"have",
"created",
".",
"Note",
"that",
... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L266-L317 |
7,429 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | UpdateRules | func (i *Instance) UpdateRules(version int, contextID string, containerInfo *policy.PUInfo, oldContainerInfo *policy.PUInfo) error {
policyrules := containerInfo.Policy
if policyrules == nil {
return errors.New("policy rules cannot be nil")
}
// We cache the old config and we use it to delete the previous
// rules. Every time we update the policy the version changes to
// its binary complement.
newCfg, err := i.newACLInfo(version, contextID, containerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
oldCfg, err := i.newACLInfo(version^1, contextID, oldContainerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
// Install all the new rules. The hooks to the new chains are appended
// and do not take effect yet.
if err := i.installRules(newCfg, containerInfo); err != nil {
return nil
}
// Remove mapping from old chain. By removing the old hooks the new
// hooks take priority.
if err := i.deleteChainRules(oldCfg); err != nil {
return err
}
// Delete the old chains, since there are not references any more.
if err := i.deletePUChains(oldCfg.AppChain, oldCfg.NetChain); err != nil {
return err
}
// Commit all actions in on iptables-restore function.
if err := i.ipt.Commit(); err != nil {
return err
}
// Sync all the IPSets with any new information coming from the policy.
i.synchronizePUACLs(contextID, policyrules.ApplicationACLs(), policyrules.NetworkACLs())
return nil
} | go | func (i *Instance) UpdateRules(version int, contextID string, containerInfo *policy.PUInfo, oldContainerInfo *policy.PUInfo) error {
policyrules := containerInfo.Policy
if policyrules == nil {
return errors.New("policy rules cannot be nil")
}
// We cache the old config and we use it to delete the previous
// rules. Every time we update the policy the version changes to
// its binary complement.
newCfg, err := i.newACLInfo(version, contextID, containerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
oldCfg, err := i.newACLInfo(version^1, contextID, oldContainerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
// Install all the new rules. The hooks to the new chains are appended
// and do not take effect yet.
if err := i.installRules(newCfg, containerInfo); err != nil {
return nil
}
// Remove mapping from old chain. By removing the old hooks the new
// hooks take priority.
if err := i.deleteChainRules(oldCfg); err != nil {
return err
}
// Delete the old chains, since there are not references any more.
if err := i.deletePUChains(oldCfg.AppChain, oldCfg.NetChain); err != nil {
return err
}
// Commit all actions in on iptables-restore function.
if err := i.ipt.Commit(); err != nil {
return err
}
// Sync all the IPSets with any new information coming from the policy.
i.synchronizePUACLs(contextID, policyrules.ApplicationACLs(), policyrules.NetworkACLs())
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"UpdateRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
",",
"oldContainerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"policyrules",
":=",
"co... | // UpdateRules implements the update part of the interface. Update will call
// installrules to install the new rules and then it will delete the old rules.
// For installations that do not have latests iptables-restore we time
// the operations so that the switch is almost atomic, by creating the new rules
// first. For latest kernel versions iptables-restorce will update all the rules
// in one shot. | [
"UpdateRules",
"implements",
"the",
"update",
"part",
"of",
"the",
"interface",
".",
"Update",
"will",
"call",
"installrules",
"to",
"install",
"the",
"new",
"rules",
"and",
"then",
"it",
"will",
"delete",
"the",
"old",
"rules",
".",
"For",
"installations",
... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L325-L371 |
7,430 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | CleanUp | func (i *Instance) CleanUp() error {
if err := i.cleanACLs(); err != nil {
zap.L().Error("Failed to clean acls while stopping the supervisor", zap.Error(err))
}
if err := i.ipset.DestroyAll(chainPrefix); err != nil {
zap.L().Error("Failed to clean up ipsets", zap.Error(err))
}
return nil
} | go | func (i *Instance) CleanUp() error {
if err := i.cleanACLs(); err != nil {
zap.L().Error("Failed to clean acls while stopping the supervisor", zap.Error(err))
}
if err := i.ipset.DestroyAll(chainPrefix); err != nil {
zap.L().Error("Failed to clean up ipsets", zap.Error(err))
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"CleanUp",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"i",
".",
"cleanACLs",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
... | // CleanUp requires the implementor to clean up all ACLs and destroy all
// the IP sets. | [
"CleanUp",
"requires",
"the",
"implementor",
"to",
"clean",
"up",
"all",
"ACLs",
"and",
"destroy",
"all",
"the",
"IP",
"sets",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L375-L386 |
7,431 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | initializeChains | func (i *Instance) initializeChains() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(triremChains).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(triremChains))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
return fmt.Errorf("unable to create trireme chains:%s", err)
}
for _, rule := range rules {
if len(rule) != 4 {
continue
}
if err := i.ipt.NewChain(rule[1], rule[3]); err != nil {
return err
}
}
return nil
} | go | func (i *Instance) initializeChains() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(triremChains).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(triremChains))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
return fmt.Errorf("unable to create trireme chains:%s", err)
}
for _, rule := range rules {
if len(rule) != 4 {
continue
}
if err := i.ipt.NewChain(rule[1], rule[3]); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"initializeChains",
"(",
")",
"error",
"{",
"cfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"0",
",",
"\"",
"\"",
",",
"nil",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n... | // InitializeChains initializes the chains. | [
"InitializeChains",
"initializes",
"the",
"chains",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L445-L473 |
7,432 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | configureLinuxRules | func (i *Instance) configureLinuxRules(cfg *ACLInfo) error {
// These checks are for rather unusal error scenarios. We should
// never see errors here. But better safe than sorry.
if cfg.CgroupMark == "" {
return errors.New("no mark value found")
}
if cfg.TCPPortSet == "" {
return fmt.Errorf("port set was not found for the contextID. This should not happen")
}
return i.addChainRules(cfg)
} | go | func (i *Instance) configureLinuxRules(cfg *ACLInfo) error {
// These checks are for rather unusal error scenarios. We should
// never see errors here. But better safe than sorry.
if cfg.CgroupMark == "" {
return errors.New("no mark value found")
}
if cfg.TCPPortSet == "" {
return fmt.Errorf("port set was not found for the contextID. This should not happen")
}
return i.addChainRules(cfg)
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"configureLinuxRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"error",
"{",
"// These checks are for rather unusal error scenarios. We should",
"// never see errors here. But better safe than sorry.",
"if",
"cfg",
".",
"CgroupMark",
"==",
"... | // configureLinuxRules adds the chain rules for a linux process or a UID process. | [
"configureLinuxRules",
"adds",
"the",
"chain",
"rules",
"for",
"a",
"linux",
"process",
"or",
"a",
"UID",
"process",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L483-L496 |
7,433 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | installRules | func (i *Instance) installRules(cfg *ACLInfo, containerInfo *policy.PUInfo) error {
var err error
var appACLIPset, netACLIPset []aclIPset
policyrules := containerInfo.Policy
if err := i.updateProxySet(containerInfo.Policy, cfg.ProxySetName); err != nil {
return err
}
if appACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.ApplicationACLs()); err != nil {
return err
}
if netACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.NetworkACLs()); err != nil {
return err
}
// Install the PU specific chain first.
if err := i.addContainerChain(cfg.AppChain, cfg.NetChain); err != nil {
return err
}
// If its a remote and thus container, configure container rules.
if i.mode == constants.RemoteContainer || i.mode == constants.Sidecar {
if err := i.configureContainerRules(cfg); err != nil {
return err
}
}
// If its a Linux process configure the Linux rules.
if i.mode == constants.LocalServer {
if err := i.configureLinuxRules(cfg); err != nil {
return err
}
}
isHostPU := extractors.IsHostPU(containerInfo.Runtime, i.mode)
if err := i.addExternalACLs(cfg.ContextID, cfg.AppChain, cfg.NetChain, appACLIPset, true); err != nil {
return err
}
if err := i.addExternalACLs(cfg.ContextID, cfg.NetChain, cfg.AppChain, netACLIPset, false); err != nil {
return err
}
if err := i.addPacketTrap(cfg, isHostPU); err != nil {
return err
}
return nil
} | go | func (i *Instance) installRules(cfg *ACLInfo, containerInfo *policy.PUInfo) error {
var err error
var appACLIPset, netACLIPset []aclIPset
policyrules := containerInfo.Policy
if err := i.updateProxySet(containerInfo.Policy, cfg.ProxySetName); err != nil {
return err
}
if appACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.ApplicationACLs()); err != nil {
return err
}
if netACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.NetworkACLs()); err != nil {
return err
}
// Install the PU specific chain first.
if err := i.addContainerChain(cfg.AppChain, cfg.NetChain); err != nil {
return err
}
// If its a remote and thus container, configure container rules.
if i.mode == constants.RemoteContainer || i.mode == constants.Sidecar {
if err := i.configureContainerRules(cfg); err != nil {
return err
}
}
// If its a Linux process configure the Linux rules.
if i.mode == constants.LocalServer {
if err := i.configureLinuxRules(cfg); err != nil {
return err
}
}
isHostPU := extractors.IsHostPU(containerInfo.Runtime, i.mode)
if err := i.addExternalACLs(cfg.ContextID, cfg.AppChain, cfg.NetChain, appACLIPset, true); err != nil {
return err
}
if err := i.addExternalACLs(cfg.ContextID, cfg.NetChain, cfg.AppChain, netACLIPset, false); err != nil {
return err
}
if err := i.addPacketTrap(cfg, isHostPU); err != nil {
return err
}
return nil
} | [
"func",
"(",
"i",
"*",
"Instance",
")",
"installRules",
"(",
"cfg",
"*",
"ACLInfo",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"appACLIPset",
",",
"netACLIPset",
"[",
"]",
"aclIPset",
"\n",
... | // Install rules will install all the rules and update the port sets. | [
"Install",
"rules",
"will",
"install",
"all",
"the",
"rules",
"and",
"update",
"the",
"port",
"sets",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L742-L793 |
7,434 | aporeto-inc/trireme-lib | controller/internal/supervisor/iptablesctrl/iptables.go | puPortSetName | func puPortSetName(contextID string, prefix string) string {
hash := murmur3.New64()
if _, err := io.WriteString(hash, contextID); err != nil {
return ""
}
output := base64.URLEncoding.EncodeToString(hash.Sum(nil))
if len(contextID) > 4 {
contextID = contextID[:4] + output[:4]
} else {
contextID = contextID + output[:4]
}
if len(prefix) > 16 {
prefix = prefix[:16]
}
return (prefix + contextID)
} | go | func puPortSetName(contextID string, prefix string) string {
hash := murmur3.New64()
if _, err := io.WriteString(hash, contextID); err != nil {
return ""
}
output := base64.URLEncoding.EncodeToString(hash.Sum(nil))
if len(contextID) > 4 {
contextID = contextID[:4] + output[:4]
} else {
contextID = contextID + output[:4]
}
if len(prefix) > 16 {
prefix = prefix[:16]
}
return (prefix + contextID)
} | [
"func",
"puPortSetName",
"(",
"contextID",
"string",
",",
"prefix",
"string",
")",
"string",
"{",
"hash",
":=",
"murmur3",
".",
"New64",
"(",
")",
"\n\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"hash",
",",
"contextID",
")",
";",
... | // puPortSetName returns the name of the pu portset. | [
"puPortSetName",
"returns",
"the",
"name",
"of",
"the",
"pu",
"portset",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L796-L816 |
7,435 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | NewProtoListener | func NewProtoListener(mark int) *ProtoListener {
return &ProtoListener{
connection: make(chan net.Conn),
mark: mark,
}
} | go | func NewProtoListener(mark int) *ProtoListener {
return &ProtoListener{
connection: make(chan net.Conn),
mark: mark,
}
} | [
"func",
"NewProtoListener",
"(",
"mark",
"int",
")",
"*",
"ProtoListener",
"{",
"return",
"&",
"ProtoListener",
"{",
"connection",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
",",
"mark",
":",
"mark",
",",
"}",
"\n",
"}"
] | // NewProtoListener creates a listener for a particular protocol. | [
"NewProtoListener",
"creates",
"a",
"listener",
"for",
"a",
"particular",
"protocol",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L24-L29 |
7,436 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | Accept | func (p *ProtoListener) Accept() (net.Conn, error) {
c, ok := <-p.connection
if !ok {
return nil, fmt.Errorf("mux: listener closed")
}
return c, nil
} | go | func (p *ProtoListener) Accept() (net.Conn, error) {
c, ok := <-p.connection
if !ok {
return nil, fmt.Errorf("mux: listener closed")
}
return c, nil
} | [
"func",
"(",
"p",
"*",
"ProtoListener",
")",
"Accept",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"ok",
":=",
"<-",
"p",
".",
"connection",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
... | // Accept accepts new connections over the channel. | [
"Accept",
"accepts",
"new",
"connections",
"over",
"the",
"channel",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L32-L38 |
7,437 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | NewMultiplexedListener | func NewMultiplexedListener(l net.Listener, mark int, registry *serviceregistry.Registry, puID string) *MultiplexedListener {
return &MultiplexedListener{
root: l,
done: make(chan struct{}),
shutdown: make(chan struct{}),
wg: sync.WaitGroup{},
protomap: map[common.ListenerType]*ProtoListener{},
registry: registry,
localIPs: markedconn.GetInterfaces(),
mark: mark,
puID: puID,
}
} | go | func NewMultiplexedListener(l net.Listener, mark int, registry *serviceregistry.Registry, puID string) *MultiplexedListener {
return &MultiplexedListener{
root: l,
done: make(chan struct{}),
shutdown: make(chan struct{}),
wg: sync.WaitGroup{},
protomap: map[common.ListenerType]*ProtoListener{},
registry: registry,
localIPs: markedconn.GetInterfaces(),
mark: mark,
puID: puID,
}
} | [
"func",
"NewMultiplexedListener",
"(",
"l",
"net",
".",
"Listener",
",",
"mark",
"int",
",",
"registry",
"*",
"serviceregistry",
".",
"Registry",
",",
"puID",
"string",
")",
"*",
"MultiplexedListener",
"{",
"return",
"&",
"MultiplexedListener",
"{",
"root",
":... | // NewMultiplexedListener returns a new multiplexed listener. Caller
// must register protocols outside of the new object creation. | [
"NewMultiplexedListener",
"returns",
"a",
"new",
"multiplexed",
"listener",
".",
"Caller",
"must",
"register",
"protocols",
"outside",
"of",
"the",
"new",
"object",
"creation",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L59-L72 |
7,438 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | RegisterListener | func (m *MultiplexedListener) RegisterListener(ltype common.ListenerType) (*ProtoListener, error) {
m.Lock()
defer m.Unlock()
if _, ok := m.protomap[ltype]; ok {
return nil, fmt.Errorf("Cannot register same listener type multiple times")
}
p := &ProtoListener{
Listener: m.root,
connection: make(chan net.Conn),
mark: m.mark,
}
m.protomap[ltype] = p
return p, nil
} | go | func (m *MultiplexedListener) RegisterListener(ltype common.ListenerType) (*ProtoListener, error) {
m.Lock()
defer m.Unlock()
if _, ok := m.protomap[ltype]; ok {
return nil, fmt.Errorf("Cannot register same listener type multiple times")
}
p := &ProtoListener{
Listener: m.root,
connection: make(chan net.Conn),
mark: m.mark,
}
m.protomap[ltype] = p
return p, nil
} | [
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"RegisterListener",
"(",
"ltype",
"common",
".",
"ListenerType",
")",
"(",
"*",
"ProtoListener",
",",
"error",
")",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",... | // RegisterListener registers a new listener. It returns the listener that the various
// protocol servers should use. If defaultListener is set, this will become
// the default listener if no match is found. Obviously, there cannot be more
// than one default. | [
"RegisterListener",
"registers",
"a",
"new",
"listener",
".",
"It",
"returns",
"the",
"listener",
"that",
"the",
"various",
"protocol",
"servers",
"should",
"use",
".",
"If",
"defaultListener",
"is",
"set",
"this",
"will",
"become",
"the",
"default",
"listener",... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L78-L94 |
7,439 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | UnregisterListener | func (m *MultiplexedListener) UnregisterListener(ltype common.ListenerType) error {
m.Lock()
defer m.Unlock()
delete(m.protomap, ltype)
return nil
} | go | func (m *MultiplexedListener) UnregisterListener(ltype common.ListenerType) error {
m.Lock()
defer m.Unlock()
delete(m.protomap, ltype)
return nil
} | [
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"UnregisterListener",
"(",
"ltype",
"common",
".",
"ListenerType",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"m",
".",
"protomap... | // UnregisterListener unregisters a listener. It returns an error if there are services
// associated with this listener. | [
"UnregisterListener",
"unregisters",
"a",
"listener",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"are",
"services",
"associated",
"with",
"this",
"listener",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L98-L105 |
7,440 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | RegisterDefaultListener | func (m *MultiplexedListener) RegisterDefaultListener(p *ProtoListener) error {
m.Lock()
defer m.Unlock()
if m.defaultListener != nil {
return fmt.Errorf("Default listener already registered")
}
m.defaultListener = p
return nil
} | go | func (m *MultiplexedListener) RegisterDefaultListener(p *ProtoListener) error {
m.Lock()
defer m.Unlock()
if m.defaultListener != nil {
return fmt.Errorf("Default listener already registered")
}
m.defaultListener = p
return nil
} | [
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"RegisterDefaultListener",
"(",
"p",
"*",
"ProtoListener",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"defaultListener",
"!=",
"... | // RegisterDefaultListener registers a default listener. | [
"RegisterDefaultListener",
"registers",
"a",
"default",
"listener",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L108-L118 |
7,441 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | UnregisterDefaultListener | func (m *MultiplexedListener) UnregisterDefaultListener() error {
m.Lock()
defer m.Unlock()
if m.defaultListener == nil {
return fmt.Errorf("No default listener registered")
}
m.defaultListener = nil
return nil
} | go | func (m *MultiplexedListener) UnregisterDefaultListener() error {
m.Lock()
defer m.Unlock()
if m.defaultListener == nil {
return fmt.Errorf("No default listener registered")
}
m.defaultListener = nil
return nil
} | [
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"UnregisterDefaultListener",
"(",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"defaultListener",
"==",
"nil",
"{",
"return",
"fmt... | // UnregisterDefaultListener unregisters the default listener. | [
"UnregisterDefaultListener",
"unregisters",
"the",
"default",
"listener",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L121-L132 |
7,442 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/protomux/protomux.go | Serve | func (m *MultiplexedListener) Serve(ctx context.Context) error {
defer func() {
close(m.done)
m.wg.Wait()
m.RLock()
defer m.RUnlock()
for _, l := range m.protomap {
close(l.connection)
// Drain the connections enqueued for the listener.
for c := range l.connection {
c.Close() // nolint
}
}
}()
for {
select {
case <-ctx.Done():
return nil
case <-m.shutdown:
return nil
default:
c, err := m.root.Accept()
if err != nil {
return err
}
m.wg.Add(1)
go m.serve(c)
}
}
} | go | func (m *MultiplexedListener) Serve(ctx context.Context) error {
defer func() {
close(m.done)
m.wg.Wait()
m.RLock()
defer m.RUnlock()
for _, l := range m.protomap {
close(l.connection)
// Drain the connections enqueued for the listener.
for c := range l.connection {
c.Close() // nolint
}
}
}()
for {
select {
case <-ctx.Done():
return nil
case <-m.shutdown:
return nil
default:
c, err := m.root.Accept()
if err != nil {
return err
}
m.wg.Add(1)
go m.serve(c)
}
}
} | [
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"Serve",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"close",
"(",
"m",
".",
"done",
")",
"\n",
"m",
".",
"wg",
".",
"Wait",
"(",
")",
"\n\n",
"m",
... | // Serve will demux the connections | [
"Serve",
"will",
"demux",
"the",
"connections"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L140-L173 |
7,443 | aporeto-inc/trireme-lib | controller/pkg/env/parameters.go | GetParameters | func GetParameters() (logToConsole bool, logID string, logLevel string, logFormat string, compressedTagsVersion claimsheader.CompressionType) {
logLevel = os.Getenv(constants.EnvLogLevel)
if logLevel == "" {
logLevel = "info"
}
logFormat = os.Getenv(constants.EnvLogFormat)
if logLevel == "" {
logFormat = "json"
}
if console := os.Getenv(constants.EnvLogToConsole); console == constants.EnvLogToConsoleEnable {
logToConsole = true
}
logID = os.Getenv(constants.EnvLogID)
compressedTagsVersion = claimsheader.CompressionTypeNone
if console := os.Getenv(constants.EnvCompressedTags); console != string(claimsheader.CompressionTypeNone) {
if console == string(claimsheader.CompressionTypeV1) {
compressedTagsVersion = claimsheader.CompressionTypeV1
} else if console == string(claimsheader.CompressionTypeV2) {
compressedTagsVersion = claimsheader.CompressionTypeV2
}
}
return
} | go | func GetParameters() (logToConsole bool, logID string, logLevel string, logFormat string, compressedTagsVersion claimsheader.CompressionType) {
logLevel = os.Getenv(constants.EnvLogLevel)
if logLevel == "" {
logLevel = "info"
}
logFormat = os.Getenv(constants.EnvLogFormat)
if logLevel == "" {
logFormat = "json"
}
if console := os.Getenv(constants.EnvLogToConsole); console == constants.EnvLogToConsoleEnable {
logToConsole = true
}
logID = os.Getenv(constants.EnvLogID)
compressedTagsVersion = claimsheader.CompressionTypeNone
if console := os.Getenv(constants.EnvCompressedTags); console != string(claimsheader.CompressionTypeNone) {
if console == string(claimsheader.CompressionTypeV1) {
compressedTagsVersion = claimsheader.CompressionTypeV1
} else if console == string(claimsheader.CompressionTypeV2) {
compressedTagsVersion = claimsheader.CompressionTypeV2
}
}
return
} | [
"func",
"GetParameters",
"(",
")",
"(",
"logToConsole",
"bool",
",",
"logID",
"string",
",",
"logLevel",
"string",
",",
"logFormat",
"string",
",",
"compressedTagsVersion",
"claimsheader",
".",
"CompressionType",
")",
"{",
"logLevel",
"=",
"os",
".",
"Getenv",
... | // GetParameters retrieves log parameters for Remote Enforcer. | [
"GetParameters",
"retrieves",
"log",
"parameters",
"for",
"Remote",
"Enforcer",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/env/parameters.go#L21-L49 |
7,444 | aporeto-inc/trireme-lib | monitor/extractors/kubernetes.go | isPodInfraContainer | func isPodInfraContainer(runtime policy.RuntimeReader) bool {
// The Infra container can be found by checking env. variable.
tagContent, ok := runtime.Tag(KubernetesContainerNameIdentifier)
if !ok || tagContent != KubernetesInfraContainerName {
return false
}
return true
} | go | func isPodInfraContainer(runtime policy.RuntimeReader) bool {
// The Infra container can be found by checking env. variable.
tagContent, ok := runtime.Tag(KubernetesContainerNameIdentifier)
if !ok || tagContent != KubernetesInfraContainerName {
return false
}
return true
} | [
"func",
"isPodInfraContainer",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"bool",
"{",
"// The Infra container can be found by checking env. variable.",
"tagContent",
",",
"ok",
":=",
"runtime",
".",
"Tag",
"(",
"KubernetesContainerNameIdentifier",
")",
"\n",
"i... | // isPodInfraContainer returns true if the runtime represents the infra container for the POD | [
"isPodInfraContainer",
"returns",
"true",
"if",
"the",
"runtime",
"represents",
"the",
"infra",
"container",
"for",
"the",
"POD"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/kubernetes.go#L95-L103 |
7,445 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/client.go | NewStatsClient | func NewStatsClient(cr statscollector.Collector) (StatsClient, error) {
sc := &statsClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
statsChannel: os.Getenv(constants.EnvStatsChannel),
statsInterval: defaultStatsIntervalMiliseconds * time.Millisecond,
userRetention: defaultUserRetention * time.Minute,
stop: make(chan bool),
}
if sc.statsChannel == "" {
return nil, errors.New("no path to stats socket provided")
}
if sc.secret == "" {
return nil, errors.New("no secret provided for stats channel")
}
return sc, nil
} | go | func NewStatsClient(cr statscollector.Collector) (StatsClient, error) {
sc := &statsClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
statsChannel: os.Getenv(constants.EnvStatsChannel),
statsInterval: defaultStatsIntervalMiliseconds * time.Millisecond,
userRetention: defaultUserRetention * time.Minute,
stop: make(chan bool),
}
if sc.statsChannel == "" {
return nil, errors.New("no path to stats socket provided")
}
if sc.secret == "" {
return nil, errors.New("no secret provided for stats channel")
}
return sc, nil
} | [
"func",
"NewStatsClient",
"(",
"cr",
"statscollector",
".",
"Collector",
")",
"(",
"StatsClient",
",",
"error",
")",
"{",
"sc",
":=",
"&",
"statsClient",
"{",
"collector",
":",
"cr",
",",
"rpchdl",
":",
"rpcwrapper",
".",
"NewRPCWrapper",
"(",
")",
",",
... | // NewStatsClient initializes a new stats client | [
"NewStatsClient",
"initializes",
"a",
"new",
"stats",
"client"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L36-L57 |
7,446 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/client.go | sendStats | func (s *statsClient) sendStats(ctx context.Context) {
ticker := time.NewTicker(s.statsInterval)
userTicker := time.NewTicker(s.userRetention)
// nolint : gosimple
for {
select {
case <-ticker.C:
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
continue
}
s.sendRequest(flows, users)
case <-userTicker.C:
s.collector.FlushUserCache()
case <-ctx.Done():
return
}
}
} | go | func (s *statsClient) sendStats(ctx context.Context) {
ticker := time.NewTicker(s.statsInterval)
userTicker := time.NewTicker(s.userRetention)
// nolint : gosimple
for {
select {
case <-ticker.C:
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
continue
}
s.sendRequest(flows, users)
case <-userTicker.C:
s.collector.FlushUserCache()
case <-ctx.Done():
return
}
}
} | [
"func",
"(",
"s",
"*",
"statsClient",
")",
"sendStats",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"s",
".",
"statsInterval",
")",
"\n",
"userTicker",
":=",
"time",
".",
"NewTicker",
"(",
"s",
".",
... | // sendStats async function which makes a rpc call to send stats every STATS_INTERVAL | [
"sendStats",
"async",
"function",
"which",
"makes",
"a",
"rpc",
"call",
"to",
"send",
"stats",
"every",
"STATS_INTERVAL"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L60-L83 |
7,447 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/client.go | SendStats | func (s *statsClient) SendStats() {
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
zap.L().Debug("Flows and UserRecords are nil while sending stats to collector")
return
}
s.sendRequest(flows, users)
} | go | func (s *statsClient) SendStats() {
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
zap.L().Debug("Flows and UserRecords are nil while sending stats to collector")
return
}
s.sendRequest(flows, users)
} | [
"func",
"(",
"s",
"*",
"statsClient",
")",
"SendStats",
"(",
")",
"{",
"flows",
":=",
"s",
".",
"collector",
".",
"GetAllRecords",
"(",
")",
"\n",
"users",
":=",
"s",
".",
"collector",
".",
"GetUserRecords",
"(",
")",
"\n",
"if",
"flows",
"==",
"nil"... | // SendStats sends all the stats from the cache | [
"SendStats",
"sends",
"all",
"the",
"stats",
"from",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L105-L115 |
7,448 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statsclient/client.go | Run | func (s *statsClient) Run(ctx context.Context) error {
if err := s.rpchdl.NewRPCClient(statsContextID, s.statsChannel, s.secret); err != nil {
zap.L().Error("Stats RPC client cannot connect", zap.Error(err))
return err
}
go s.sendStats(ctx)
return nil
} | go | func (s *statsClient) Run(ctx context.Context) error {
if err := s.rpchdl.NewRPCClient(statsContextID, s.statsChannel, s.secret); err != nil {
zap.L().Error("Stats RPC client cannot connect", zap.Error(err))
return err
}
go s.sendStats(ctx)
return nil
} | [
"func",
"(",
"s",
"*",
"statsClient",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"rpchdl",
".",
"NewRPCClient",
"(",
"statsContextID",
",",
"s",
".",
"statsChannel",
",",
"s",
".",
"secret",
")"... | // Start This is an private function called by the remoteenforcer to connect back
// to the controller over a stats channel | [
"Start",
"This",
"is",
"an",
"private",
"function",
"called",
"by",
"the",
"remoteenforcer",
"to",
"connect",
"back",
"to",
"the",
"controller",
"over",
"a",
"stats",
"channel"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L119-L128 |
7,449 | aporeto-inc/trireme-lib | controller/controller.go | New | func New(serverID string, mode constants.ModeType, opts ...Option) TriremeController {
c := &config{
serverID: serverID,
collector: collector.NewDefaultCollector(),
mode: mode,
fq: fqconfig.NewFilterQueueWithDefaults(),
mutualAuth: true,
validity: time.Hour * 8760,
procMountPoint: constants.DefaultProcMountPoint,
externalIPcacheTimeout: -1,
remoteParameters: &env.RemoteParameters{
LogToConsole: true,
LogFormat: "console",
LogLevel: "info",
LogWithID: false,
CompressedTags: claimsheader.CompressionTypeV1,
},
}
for _, opt := range opts {
opt(c)
}
zap.L().Debug("Trireme configuration", zap.String("configuration", fmt.Sprintf("%+v", c)))
return newTrireme(c)
} | go | func New(serverID string, mode constants.ModeType, opts ...Option) TriremeController {
c := &config{
serverID: serverID,
collector: collector.NewDefaultCollector(),
mode: mode,
fq: fqconfig.NewFilterQueueWithDefaults(),
mutualAuth: true,
validity: time.Hour * 8760,
procMountPoint: constants.DefaultProcMountPoint,
externalIPcacheTimeout: -1,
remoteParameters: &env.RemoteParameters{
LogToConsole: true,
LogFormat: "console",
LogLevel: "info",
LogWithID: false,
CompressedTags: claimsheader.CompressionTypeV1,
},
}
for _, opt := range opts {
opt(c)
}
zap.L().Debug("Trireme configuration", zap.String("configuration", fmt.Sprintf("%+v", c)))
return newTrireme(c)
} | [
"func",
"New",
"(",
"serverID",
"string",
",",
"mode",
"constants",
".",
"ModeType",
",",
"opts",
"...",
"Option",
")",
"TriremeController",
"{",
"c",
":=",
"&",
"config",
"{",
"serverID",
":",
"serverID",
",",
"collector",
":",
"collector",
".",
"NewDefau... | // New returns a trireme interface implementation based on configuration provided. | [
"New",
"returns",
"a",
"trireme",
"interface",
"implementation",
"based",
"on",
"configuration",
"provided",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L44-L71 |
7,450 | aporeto-inc/trireme-lib | controller/controller.go | Run | func (t *trireme) Run(ctx context.Context) error {
// Start all the supervisors.
for _, s := range t.supervisors {
if err := s.Run(ctx); err != nil {
zap.L().Error("Error when starting the supervisor", zap.Error(err))
return fmt.Errorf("Error while starting supervisor %v", err)
}
}
// Start all the enforcers.
for _, e := range t.enforcers {
if err := e.Run(ctx); err != nil {
return fmt.Errorf("unable to start the enforcer: %s", err)
}
}
go t.runIPTraceCollector(ctx)
return nil
} | go | func (t *trireme) Run(ctx context.Context) error {
// Start all the supervisors.
for _, s := range t.supervisors {
if err := s.Run(ctx); err != nil {
zap.L().Error("Error when starting the supervisor", zap.Error(err))
return fmt.Errorf("Error while starting supervisor %v", err)
}
}
// Start all the enforcers.
for _, e := range t.enforcers {
if err := e.Run(ctx); err != nil {
return fmt.Errorf("unable to start the enforcer: %s", err)
}
}
go t.runIPTraceCollector(ctx)
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"// Start all the supervisors.",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"if",
"err",
":=",
"s",
".",
"Run",
"(",
"ctx"... | // Run starts the supervisor and the enforcer and go routines. It doesn't try to clean
// up if something went wrong. It will be up to the caller to decide what to do. | [
"Run",
"starts",
"the",
"supervisor",
"and",
"the",
"enforcer",
"and",
"go",
"routines",
".",
"It",
"doesn",
"t",
"try",
"to",
"clean",
"up",
"if",
"something",
"went",
"wrong",
".",
"It",
"will",
"be",
"up",
"to",
"the",
"caller",
"to",
"decide",
"wha... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L75-L93 |
7,451 | aporeto-inc/trireme-lib | controller/controller.go | CleanUp | func (t *trireme) CleanUp() error {
for _, s := range t.supervisors {
s.CleanUp() // nolint
}
for _, e := range t.enforcers {
e.CleanUp() // nolint
}
return nil
} | go | func (t *trireme) CleanUp() error {
for _, s := range t.supervisors {
s.CleanUp() // nolint
}
for _, e := range t.enforcers {
e.CleanUp() // nolint
}
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"CleanUp",
"(",
")",
"error",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"s",
".",
"CleanUp",
"(",
")",
"// nolint",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"t"... | // CleanUp cleans all the acls and all the remote supervisors | [
"CleanUp",
"cleans",
"all",
"the",
"acls",
"and",
"all",
"the",
"remote",
"supervisors"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L96-L105 |
7,452 | aporeto-inc/trireme-lib | controller/controller.go | Enforce | func (t *trireme) Enforce(ctx context.Context, puID string, policy *policy.PUPolicy, runtime *policy.PURuntime) error {
lock, _ := t.locks.LoadOrStore(puID, &sync.Mutex{})
lock.(*sync.Mutex).Lock()
defer lock.(*sync.Mutex).Unlock()
return t.doHandleCreate(puID, policy, runtime)
} | go | func (t *trireme) Enforce(ctx context.Context, puID string, policy *policy.PUPolicy, runtime *policy.PURuntime) error {
lock, _ := t.locks.LoadOrStore(puID, &sync.Mutex{})
lock.(*sync.Mutex).Lock()
defer lock.(*sync.Mutex).Unlock()
return t.doHandleCreate(puID, policy, runtime)
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"Enforce",
"(",
"ctx",
"context",
".",
"Context",
",",
"puID",
"string",
",",
"policy",
"*",
"policy",
".",
"PUPolicy",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"lock",
",",
"_",
":=",... | // Enforce asks the controller to enforce policy to a processing unit | [
"Enforce",
"asks",
"the",
"controller",
"to",
"enforce",
"policy",
"to",
"a",
"processing",
"unit"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L108-L113 |
7,453 | aporeto-inc/trireme-lib | controller/controller.go | UpdateSecrets | func (t *trireme) UpdateSecrets(secrets secrets.Secrets) error {
for _, enforcer := range t.enforcers {
if err := enforcer.UpdateSecrets(secrets); err != nil {
zap.L().Error("unable to update secrets", zap.Error(err))
}
}
return nil
} | go | func (t *trireme) UpdateSecrets(secrets secrets.Secrets) error {
for _, enforcer := range t.enforcers {
if err := enforcer.UpdateSecrets(secrets); err != nil {
zap.L().Error("unable to update secrets", zap.Error(err))
}
}
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"UpdateSecrets",
"(",
"secrets",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"for",
"_",
",",
"enforcer",
":=",
"range",
"t",
".",
"enforcers",
"{",
"if",
"err",
":=",
"enforcer",
".",
"UpdateSecrets",
"(",
"sec... | // UpdateSecrets updates the secrets of the controllers. | [
"UpdateSecrets",
"updates",
"the",
"secrets",
"of",
"the",
"controllers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L135-L142 |
7,454 | aporeto-inc/trireme-lib | controller/controller.go | UpdateConfiguration | func (t *trireme) UpdateConfiguration(cfg *runtime.Configuration) error {
failure := false
for _, s := range t.supervisors {
err := s.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in supervisor", zap.Error(err))
failure = true
}
}
for _, e := range t.enforcers {
err := e.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in cotnroller", zap.Error(err))
failure = true
}
}
if failure {
return fmt.Errorf("configuration update failed")
}
return nil
} | go | func (t *trireme) UpdateConfiguration(cfg *runtime.Configuration) error {
failure := false
for _, s := range t.supervisors {
err := s.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in supervisor", zap.Error(err))
failure = true
}
}
for _, e := range t.enforcers {
err := e.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in cotnroller", zap.Error(err))
failure = true
}
}
if failure {
return fmt.Errorf("configuration update failed")
}
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"UpdateConfiguration",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"failure",
":=",
"false",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"err",
":=",
"s",
... | // UpdateConfiguration updates the configuration of the controller. Only
// a limited number of parameters can be updated at run time. | [
"UpdateConfiguration",
"updates",
"the",
"configuration",
"of",
"the",
"controller",
".",
"Only",
"a",
"limited",
"number",
"of",
"parameters",
"can",
"be",
"updated",
"at",
"run",
"time",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L146-L171 |
7,455 | aporeto-inc/trireme-lib | controller/controller.go | doHandleCreate | func (t *trireme) doHandleCreate(contextID string, policyInfo *policy.PUPolicy, runtimeInfo *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, policyInfo, runtimeInfo)
logEvent := &collector.ContainerRecord{
ContextID: contextID,
IPAddress: policyInfo.IPAddresses(),
Tags: policyInfo.Annotations(),
Event: collector.ContainerStart,
}
defer func() {
t.config.collector.CollectContainerEvent(logEvent)
}()
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
logEvent.Event = collector.ContainerIgnored
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup enforcer: %s", err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up state after failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup supervisor: %s", err)
}
return nil
} | go | func (t *trireme) doHandleCreate(contextID string, policyInfo *policy.PUPolicy, runtimeInfo *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, policyInfo, runtimeInfo)
logEvent := &collector.ContainerRecord{
ContextID: contextID,
IPAddress: policyInfo.IPAddresses(),
Tags: policyInfo.Annotations(),
Event: collector.ContainerStart,
}
defer func() {
t.config.collector.CollectContainerEvent(logEvent)
}()
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
logEvent.Event = collector.ContainerIgnored
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup enforcer: %s", err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up state after failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup supervisor: %s", err)
}
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"doHandleCreate",
"(",
"contextID",
"string",
",",
"policyInfo",
"*",
"policy",
".",
"PUPolicy",
",",
"runtimeInfo",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"containerInfo",
":=",
"policy",
".",
"PUInfoFromP... | // doHandleCreate is the detailed implementation of the create event. | [
"doHandleCreate",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"create",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L174-L213 |
7,456 | aporeto-inc/trireme-lib | controller/controller.go | doHandleDelete | func (t *trireme) doHandleDelete(contextID string, runtime *policy.PURuntime) error {
errS := t.supervisors[t.puTypeToEnforcerType[runtime.PUType()]].Unsupervise(contextID)
errE := t.enforcers[t.puTypeToEnforcerType[runtime.PUType()]].Unenforce(contextID)
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: nil,
Event: collector.ContainerDelete,
})
if errS != nil || errE != nil {
return fmt.Errorf("unable to delete context id %s, supervisor %s, enforcer %s", contextID, errS, errE)
}
return nil
} | go | func (t *trireme) doHandleDelete(contextID string, runtime *policy.PURuntime) error {
errS := t.supervisors[t.puTypeToEnforcerType[runtime.PUType()]].Unsupervise(contextID)
errE := t.enforcers[t.puTypeToEnforcerType[runtime.PUType()]].Unenforce(contextID)
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: nil,
Event: collector.ContainerDelete,
})
if errS != nil || errE != nil {
return fmt.Errorf("unable to delete context id %s, supervisor %s, enforcer %s", contextID, errS, errE)
}
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"doHandleDelete",
"(",
"contextID",
"string",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"errS",
":=",
"t",
".",
"supervisors",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"runtime",
".",
"P... | // doHandleDelete is the detailed implementation of the delete event. | [
"doHandleDelete",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"delete",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L216-L233 |
7,457 | aporeto-inc/trireme-lib | controller/controller.go | doUpdatePolicy | func (t *trireme) doUpdatePolicy(contextID string, newPolicy *policy.PUPolicy, runtime *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, newPolicy, runtime)
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
//We lost communication with the remote and killed it lets restart it here by feeding a create event in the request channel
if werr := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unsupervise(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("unable to update policy for pu %s: %s", contextID, err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("supervisor failed to update policy for pu %s: %s", contextID, err)
}
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: containerInfo.Runtime.Tags(),
Event: collector.ContainerUpdate,
})
return nil
} | go | func (t *trireme) doUpdatePolicy(contextID string, newPolicy *policy.PUPolicy, runtime *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, newPolicy, runtime)
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
//We lost communication with the remote and killed it lets restart it here by feeding a create event in the request channel
if werr := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unsupervise(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("unable to update policy for pu %s: %s", contextID, err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("supervisor failed to update policy for pu %s: %s", contextID, err)
}
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: containerInfo.Runtime.Tags(),
Event: collector.ContainerUpdate,
})
return nil
} | [
"func",
"(",
"t",
"*",
"trireme",
")",
"doUpdatePolicy",
"(",
"contextID",
"string",
",",
"newPolicy",
"*",
"policy",
".",
"PUPolicy",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"containerInfo",
":=",
"policy",
".",
"PUInfoFromPolicy... | // doUpdatePolicy is the detailed implementation of the update policy event. | [
"doUpdatePolicy",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"update",
"policy",
"event",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L236-L275 |
7,458 | aporeto-inc/trireme-lib | controller/pkg/packet/types.go | TCPFlagsToStr | func TCPFlagsToStr(flags uint8) string {
s := ""
if flags&0x20 == 0 {
s = s + "."
} else {
s = s + "U"
}
if flags&0x10 == 0 {
s = s + "."
} else {
s = s + "A"
}
if flags&0x08 == 0 {
s = s + "."
} else {
s = s + "P"
}
if flags&0x04 == 0 {
s = s + "."
} else {
s = s + "R"
}
if flags&0x02 == 0 {
s = s + "."
} else {
s = s + "S"
}
if flags&0x01 == 0 {
s = s + "."
} else {
s = s + "F"
}
return s
} | go | func TCPFlagsToStr(flags uint8) string {
s := ""
if flags&0x20 == 0 {
s = s + "."
} else {
s = s + "U"
}
if flags&0x10 == 0 {
s = s + "."
} else {
s = s + "A"
}
if flags&0x08 == 0 {
s = s + "."
} else {
s = s + "P"
}
if flags&0x04 == 0 {
s = s + "."
} else {
s = s + "R"
}
if flags&0x02 == 0 {
s = s + "."
} else {
s = s + "S"
}
if flags&0x01 == 0 {
s = s + "."
} else {
s = s + "F"
}
return s
} | [
"func",
"TCPFlagsToStr",
"(",
"flags",
"uint8",
")",
"string",
"{",
"s",
":=",
"\"",
"\"",
"\n",
"if",
"flags",
"&",
"0x20",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
... | // TCPFlagsToStr converts the TCP Flags to a string value that is human readable | [
"TCPFlagsToStr",
"converts",
"the",
"TCP",
"Flags",
"to",
"a",
"string",
"value",
"that",
"is",
"human",
"readable"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/types.go#L103-L136 |
7,459 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | DialMarkedWithContext | func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
d := net.Dialer{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetNonblock(int(fd), false); err != nil {
zap.L().Error("unable to set socket options", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to assing mark to socket", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 30, 1); err != nil {
zap.L().Debug("Failed to set fast open socket option", zap.Error(err))
}
})
},
}
conn, err := d.DialContext(ctx, network, addr)
if err != nil {
zap.L().Error("Failed to dial to downstream node",
zap.Error(err),
zap.String("Address", addr),
zap.String("Network type", network),
)
}
return conn, err
} | go | func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
d := net.Dialer{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetNonblock(int(fd), false); err != nil {
zap.L().Error("unable to set socket options", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to assing mark to socket", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 30, 1); err != nil {
zap.L().Debug("Failed to set fast open socket option", zap.Error(err))
}
})
},
}
conn, err := d.DialContext(ctx, network, addr)
if err != nil {
zap.L().Error("Failed to dial to downstream node",
zap.Error(err),
zap.String("Address", addr),
zap.String("Network type", network),
)
}
return conn, err
} | [
"func",
"DialMarkedWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
"string",
",",
"addr",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"d",
":=",
"net",
".",
"Dialer",
"{",
"Control",
":",
"... | // DialMarkedWithContext will dial a TCP connection to the provide address and mark the socket
// with the provided mark. | [
"DialMarkedWithContext",
"will",
"dial",
"a",
"TCP",
"connection",
"to",
"the",
"provide",
"address",
"and",
"mark",
"the",
"socket",
"with",
"the",
"provided",
"mark",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L23-L50 |
7,460 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | NewSocketListener | func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
listenerCfg := net.ListenConfig{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to mark connection", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 23, 16*1024); err != nil {
zap.L().Error("Cannot set tcp fast open options", zap.Error(err))
}
})
},
}
listener, err := listenerCfg.Listen(ctx, "tcp4", port)
if err != nil {
return nil, fmt.Errorf("Failed to create listener: %s", err)
}
return ProxiedListener{netListener: listener, mark: mark}, nil
} | go | func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
listenerCfg := net.ListenConfig{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to mark connection", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 23, 16*1024); err != nil {
zap.L().Error("Cannot set tcp fast open options", zap.Error(err))
}
})
},
}
listener, err := listenerCfg.Listen(ctx, "tcp4", port)
if err != nil {
return nil, fmt.Errorf("Failed to create listener: %s", err)
}
return ProxiedListener{netListener: listener, mark: mark}, nil
} | [
"func",
"NewSocketListener",
"(",
"ctx",
"context",
".",
"Context",
",",
"port",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"listenerCfg",
":=",
"net",
".",
"ListenConfig",
"{",
"Control",
":",
"func",
"(",
... | // NewSocketListener will create a listener and mark the socket with the provided mark. | [
"NewSocketListener",
"will",
"create",
"a",
"listener",
"and",
"mark",
"the",
"socket",
"with",
"the",
"provided",
"mark",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L53-L73 |
7,461 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | LocalAddr | func (p *ProxiedConnection) LocalAddr() net.Addr {
addr, err := net.ResolveTCPAddr("tcp", p.originalIP.String()+":"+strconv.Itoa(p.originalPort))
if err != nil {
return nil
}
return addr
} | go | func (p *ProxiedConnection) LocalAddr() net.Addr {
addr, err := net.ResolveTCPAddr("tcp", p.originalIP.String()+":"+strconv.Itoa(p.originalPort))
if err != nil {
return nil
}
return addr
} | [
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"LocalAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"p",
".",
"originalIP",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
... | // LocalAddr implements the corresponding method of net.Conn, but returns the original
// address. | [
"LocalAddr",
"implements",
"the",
"corresponding",
"method",
"of",
"net",
".",
"Conn",
"but",
"returns",
"the",
"original",
"address",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L95-L103 |
7,462 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | SetDeadline | func (p *ProxiedConnection) SetDeadline(t time.Time) error {
return p.originalTCPConnection.SetDeadline(t)
} | go | func (p *ProxiedConnection) SetDeadline(t time.Time) error {
return p.originalTCPConnection.SetDeadline(t)
} | [
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetDeadline passes the read deadline to the original TCP connection. | [
"SetDeadline",
"passes",
"the",
"read",
"deadline",
"to",
"the",
"original",
"TCP",
"connection",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L126-L128 |
7,463 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | SetReadDeadline | func (p *ProxiedConnection) SetReadDeadline(t time.Time) error {
return p.originalTCPConnection.SetReadDeadline(t)
} | go | func (p *ProxiedConnection) SetReadDeadline(t time.Time) error {
return p.originalTCPConnection.SetReadDeadline(t)
} | [
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetReadDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetReadDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetReadDeadline implements the call by passing it to the original connection. | [
"SetReadDeadline",
"implements",
"the",
"call",
"by",
"passing",
"it",
"to",
"the",
"original",
"connection",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L131-L133 |
7,464 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | SetWriteDeadline | func (p *ProxiedConnection) SetWriteDeadline(t time.Time) error {
return p.originalTCPConnection.SetWriteDeadline(t)
} | go | func (p *ProxiedConnection) SetWriteDeadline(t time.Time) error {
return p.originalTCPConnection.SetWriteDeadline(t)
} | [
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetWriteDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetWriteDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetWriteDeadline implements the call by passing it to the original connection. | [
"SetWriteDeadline",
"implements",
"the",
"call",
"by",
"passing",
"it",
"to",
"the",
"original",
"connection",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L136-L138 |
7,465 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/markedconn/markedconn.go | GetInterfaces | func GetInterfaces() map[string]struct{} {
ipmap := map[string]struct{}{}
ifaces, _ := net.Interfaces()
for _, intf := range ifaces {
addrs, _ := intf.Addrs()
for _, addr := range addrs {
ip, _, _ := net.ParseCIDR(addr.String())
if ip.To4() != nil {
ipmap[ip.String()] = struct{}{}
}
}
}
return ipmap
} | go | func GetInterfaces() map[string]struct{} {
ipmap := map[string]struct{}{}
ifaces, _ := net.Interfaces()
for _, intf := range ifaces {
addrs, _ := intf.Addrs()
for _, addr := range addrs {
ip, _, _ := net.ParseCIDR(addr.String())
if ip.To4() != nil {
ipmap[ip.String()] = struct{}{}
}
}
}
return ipmap
} | [
"func",
"GetInterfaces",
"(",
")",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"ipmap",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"ifaces",
",",
"_",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"for",
"_",... | // GetInterfaces retrieves all the local interfaces. | [
"GetInterfaces",
"retrieves",
"all",
"the",
"local",
"interfaces",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L225-L239 |
7,466 | aporeto-inc/trireme-lib | utils/cgnetcls/netcls.go | GetCgroupList | func GetCgroupList() []string {
var cgroupList []string
filelist, err := ioutil.ReadDir(filepath.Join(basePath, TriremeBasePath))
if err != nil {
return cgroupList
}
for _, file := range filelist {
if file.IsDir() {
cgroupList = append(cgroupList, file.Name())
}
}
return cgroupList
} | go | func GetCgroupList() []string {
var cgroupList []string
filelist, err := ioutil.ReadDir(filepath.Join(basePath, TriremeBasePath))
if err != nil {
return cgroupList
}
for _, file := range filelist {
if file.IsDir() {
cgroupList = append(cgroupList, file.Name())
}
}
return cgroupList
} | [
"func",
"GetCgroupList",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"cgroupList",
"[",
"]",
"string",
"\n",
"filelist",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"TriremeBasePath",
")",
")",
"\n",
"i... | // GetCgroupList geta list of all cgroup names | [
"GetCgroupList",
"geta",
"list",
"of",
"all",
"cgroup",
"names"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/netcls.go#L26-L38 |
7,467 | aporeto-inc/trireme-lib | controller/config.go | OptionCollector | func OptionCollector(c collector.EventCollector) Option {
return func(cfg *config) {
cfg.collector = c
}
} | go | func OptionCollector(c collector.EventCollector) Option {
return func(cfg *config) {
cfg.collector = c
}
} | [
"func",
"OptionCollector",
"(",
"c",
"collector",
".",
"EventCollector",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"collector",
"=",
"c",
"\n",
"}",
"\n",
"}"
] | // OptionCollector is an option to provide an external collector implementation. | [
"OptionCollector",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"collector",
"implementation",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L52-L56 |
7,468 | aporeto-inc/trireme-lib | controller/config.go | OptionDatapathService | func OptionDatapathService(s packetprocessor.PacketProcessor) Option {
return func(cfg *config) {
cfg.service = s
}
} | go | func OptionDatapathService(s packetprocessor.PacketProcessor) Option {
return func(cfg *config) {
cfg.service = s
}
} | [
"func",
"OptionDatapathService",
"(",
"s",
"packetprocessor",
".",
"PacketProcessor",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"service",
"=",
"s",
"\n",
"}",
"\n",
"}"
] | // OptionDatapathService is an option to provide an external datapath service implementation. | [
"OptionDatapathService",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"datapath",
"service",
"implementation",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L59-L63 |
7,469 | aporeto-inc/trireme-lib | controller/config.go | OptionSecret | func OptionSecret(s secrets.Secrets) Option {
return func(cfg *config) {
cfg.secret = s
}
} | go | func OptionSecret(s secrets.Secrets) Option {
return func(cfg *config) {
cfg.secret = s
}
} | [
"func",
"OptionSecret",
"(",
"s",
"secrets",
".",
"Secrets",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"secret",
"=",
"s",
"\n",
"}",
"\n",
"}"
] | // OptionSecret is an option to provide an external datapath service implementation. | [
"OptionSecret",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"datapath",
"service",
"implementation",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L66-L70 |
7,470 | aporeto-inc/trireme-lib | controller/config.go | OptionEnforceFqConfig | func OptionEnforceFqConfig(f *fqconfig.FilterQueue) Option {
return func(cfg *config) {
cfg.fq = f
}
} | go | func OptionEnforceFqConfig(f *fqconfig.FilterQueue) Option {
return func(cfg *config) {
cfg.fq = f
}
} | [
"func",
"OptionEnforceFqConfig",
"(",
"f",
"*",
"fqconfig",
".",
"FilterQueue",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"fq",
"=",
"f",
"\n",
"}",
"\n",
"}"
] | // OptionEnforceFqConfig is an option to override filter queues. | [
"OptionEnforceFqConfig",
"is",
"an",
"option",
"to",
"override",
"filter",
"queues",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L80-L84 |
7,471 | aporeto-inc/trireme-lib | controller/config.go | OptionRuntimeConfiguration | func OptionRuntimeConfiguration(c *runtime.Configuration) Option {
return func(cfg *config) {
cfg.runtimeCfg = c
}
} | go | func OptionRuntimeConfiguration(c *runtime.Configuration) Option {
return func(cfg *config) {
cfg.runtimeCfg = c
}
} | [
"func",
"OptionRuntimeConfiguration",
"(",
"c",
"*",
"runtime",
".",
"Configuration",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"runtimeCfg",
"=",
"c",
"\n",
"}",
"\n",
"}"
] | // OptionRuntimeConfiguration is an option to provide target network configuration. | [
"OptionRuntimeConfiguration",
"is",
"an",
"option",
"to",
"provide",
"target",
"network",
"configuration",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L94-L98 |
7,472 | aporeto-inc/trireme-lib | controller/config.go | OptionRuntimeErrorChannel | func OptionRuntimeErrorChannel(errorChannel chan *policy.RuntimeError) Option {
return func(cfg *config) {
cfg.runtimeErrorChannel = errorChannel
}
} | go | func OptionRuntimeErrorChannel(errorChannel chan *policy.RuntimeError) Option {
return func(cfg *config) {
cfg.runtimeErrorChannel = errorChannel
}
} | [
"func",
"OptionRuntimeErrorChannel",
"(",
"errorChannel",
"chan",
"*",
"policy",
".",
"RuntimeError",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"runtimeErrorChannel",
"=",
"errorChannel",
"\n",
"}",
"\n\n",
"}"
] | // OptionRuntimeErrorChannel configures the error channel for the policy engine. | [
"OptionRuntimeErrorChannel",
"configures",
"the",
"error",
"channel",
"for",
"the",
"policy",
"engine",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L108-L113 |
7,473 | aporeto-inc/trireme-lib | controller/config.go | OptionRemoteParameters | func OptionRemoteParameters(p *env.RemoteParameters) Option {
return func(cfg *config) {
cfg.remoteParameters = p
}
} | go | func OptionRemoteParameters(p *env.RemoteParameters) Option {
return func(cfg *config) {
cfg.remoteParameters = p
}
} | [
"func",
"OptionRemoteParameters",
"(",
"p",
"*",
"env",
".",
"RemoteParameters",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"remoteParameters",
"=",
"p",
"\n",
"}",
"\n",
"}"
] | // OptionRemoteParameters is an option to set the parameters for the remote | [
"OptionRemoteParameters",
"is",
"an",
"option",
"to",
"set",
"the",
"parameters",
"for",
"the",
"remote"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L123-L127 |
7,474 | aporeto-inc/trireme-lib | controller/config.go | newTrireme | func newTrireme(c *config) TriremeController {
var err error
t := &trireme{
config: c,
enforcers: map[constants.ModeType]enforcer.Enforcer{},
supervisors: map[constants.ModeType]supervisor.Supervisor{},
puTypeToEnforcerType: map[common.PUType]constants.ModeType{},
locks: sync.Map{},
enablingTrace: make(chan *traceTrigger, 10),
}
zap.L().Debug("Creating Enforcers")
if err = t.newEnforcers(); err != nil {
zap.L().Error("Unable to create datapath enforcers", zap.Error(err))
return nil
}
zap.L().Debug("Creating Supervisors")
if err = t.newSupervisors(); err != nil {
zap.L().Error("Unable to start datapath supervisor", zap.Error(err))
return nil
}
if c.linuxProcess {
t.puTypeToEnforcerType[common.LinuxProcessPU] = constants.LocalServer
t.puTypeToEnforcerType[common.UIDLoginPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostNetworkPU] = constants.LocalServer
t.puTypeToEnforcerType[common.SSHSessionPU] = constants.LocalServer
}
if t.config.mode == constants.RemoteContainer {
t.puTypeToEnforcerType[common.ContainerPU] = constants.RemoteContainer
t.puTypeToEnforcerType[common.KubernetesPU] = constants.RemoteContainer
}
if t.config.mode == constants.Sidecar {
t.puTypeToEnforcerType[common.ContainerPU] = constants.Sidecar
}
return t
} | go | func newTrireme(c *config) TriremeController {
var err error
t := &trireme{
config: c,
enforcers: map[constants.ModeType]enforcer.Enforcer{},
supervisors: map[constants.ModeType]supervisor.Supervisor{},
puTypeToEnforcerType: map[common.PUType]constants.ModeType{},
locks: sync.Map{},
enablingTrace: make(chan *traceTrigger, 10),
}
zap.L().Debug("Creating Enforcers")
if err = t.newEnforcers(); err != nil {
zap.L().Error("Unable to create datapath enforcers", zap.Error(err))
return nil
}
zap.L().Debug("Creating Supervisors")
if err = t.newSupervisors(); err != nil {
zap.L().Error("Unable to start datapath supervisor", zap.Error(err))
return nil
}
if c.linuxProcess {
t.puTypeToEnforcerType[common.LinuxProcessPU] = constants.LocalServer
t.puTypeToEnforcerType[common.UIDLoginPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostNetworkPU] = constants.LocalServer
t.puTypeToEnforcerType[common.SSHSessionPU] = constants.LocalServer
}
if t.config.mode == constants.RemoteContainer {
t.puTypeToEnforcerType[common.ContainerPU] = constants.RemoteContainer
t.puTypeToEnforcerType[common.KubernetesPU] = constants.RemoteContainer
}
if t.config.mode == constants.Sidecar {
t.puTypeToEnforcerType[common.ContainerPU] = constants.Sidecar
}
return t
} | [
"func",
"newTrireme",
"(",
"c",
"*",
"config",
")",
"TriremeController",
"{",
"var",
"err",
"error",
"\n\n",
"t",
":=",
"&",
"trireme",
"{",
"config",
":",
"c",
",",
"enforcers",
":",
"map",
"[",
"constants",
".",
"ModeType",
"]",
"enforcer",
".",
"Enf... | // newTrireme returns a reference to the trireme object based on the parameter subelements. | [
"newTrireme",
"returns",
"a",
"reference",
"to",
"the",
"trireme",
"object",
"based",
"on",
"the",
"parameter",
"subelements",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L233-L276 |
7,475 | aporeto-inc/trireme-lib | monitor/internal/linux/processor.go | generateContextID | func (l *linuxProcessor) generateContextID(eventInfo *common.EventInfo) (string, error) {
puID := eventInfo.PUID
if eventInfo.Cgroup == "" {
return puID, nil
}
if !l.regStop.Match([]byte(eventInfo.Cgroup)) {
return "", fmt.Errorf("invalid pu id: %s", eventInfo.Cgroup)
}
puID = baseName(eventInfo.Cgroup, "/")
if eventInfo.PUType == common.SSHSessionPU {
return "ssh-" + puID, nil
}
return puID, nil
} | go | func (l *linuxProcessor) generateContextID(eventInfo *common.EventInfo) (string, error) {
puID := eventInfo.PUID
if eventInfo.Cgroup == "" {
return puID, nil
}
if !l.regStop.Match([]byte(eventInfo.Cgroup)) {
return "", fmt.Errorf("invalid pu id: %s", eventInfo.Cgroup)
}
puID = baseName(eventInfo.Cgroup, "/")
if eventInfo.PUType == common.SSHSessionPU {
return "ssh-" + puID, nil
}
return puID, nil
} | [
"func",
"(",
"l",
"*",
"linuxProcessor",
")",
"generateContextID",
"(",
"eventInfo",
"*",
"common",
".",
"EventInfo",
")",
"(",
"string",
",",
"error",
")",
"{",
"puID",
":=",
"eventInfo",
".",
"PUID",
"\n",
"if",
"eventInfo",
".",
"Cgroup",
"==",
"\"",
... | // generateContextID creates the puID from the event information | [
"generateContextID",
"creates",
"the",
"puID",
"from",
"the",
"event",
"information"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/linux/processor.go#L299-L317 |
7,476 | aporeto-inc/trireme-lib | plugins/pam/uidmonitorpam.go | pam_sm_open_session | func pam_sm_open_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
C.initLog()
user := C.get_user(pamh)
service := C.get_service(pamh)
metadatamap := []string{}
userstring := "user=" + C.GoString(user)
metadatamap = append(metadatamap, userstring)
if groups, err := getGroupList(C.GoString(user)); err == nil {
metadatamap = append(metadatamap, groups...)
}
if service != nil {
metadatamap = append(metadatamap, "SessionType="+C.GoString(service))
} else {
metadatamap = append(metadatamap, "SessionType=login")
}
request := &common.EventInfo{
PUType: common.UIDLoginPU,
PUID: C.GoString(user),
Name: "login-" + C.GoString(user),
PID: int32(os.Getpid()),
Tags: metadatamap,
EventType: "start",
}
if C.is_root(user) == 1 {
//Do nothing this is login shell account
} else {
//Do something
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
defer func() {
_ = slog.Close()
}()
client, err := client.NewClient(common.TriremeSocket)
if err != nil {
return C.PAM_SUCCESS
}
slog.Alert("Calling Trireme") // nolit
if err := client.SendRequest(request); err != nil {
err = fmt.Errorf("Policy Server call failed %s", err)
_ = slog.Alert(err.Error())
return C.PAM_SESSION_ERR
}
}
return C.PAM_SUCCESS
} | go | func pam_sm_open_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
C.initLog()
user := C.get_user(pamh)
service := C.get_service(pamh)
metadatamap := []string{}
userstring := "user=" + C.GoString(user)
metadatamap = append(metadatamap, userstring)
if groups, err := getGroupList(C.GoString(user)); err == nil {
metadatamap = append(metadatamap, groups...)
}
if service != nil {
metadatamap = append(metadatamap, "SessionType="+C.GoString(service))
} else {
metadatamap = append(metadatamap, "SessionType=login")
}
request := &common.EventInfo{
PUType: common.UIDLoginPU,
PUID: C.GoString(user),
Name: "login-" + C.GoString(user),
PID: int32(os.Getpid()),
Tags: metadatamap,
EventType: "start",
}
if C.is_root(user) == 1 {
//Do nothing this is login shell account
} else {
//Do something
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
defer func() {
_ = slog.Close()
}()
client, err := client.NewClient(common.TriremeSocket)
if err != nil {
return C.PAM_SUCCESS
}
slog.Alert("Calling Trireme") // nolit
if err := client.SendRequest(request); err != nil {
err = fmt.Errorf("Policy Server call failed %s", err)
_ = slog.Alert(err.Error())
return C.PAM_SESSION_ERR
}
}
return C.PAM_SUCCESS
} | [
"func",
"pam_sm_open_session",
"(",
"pamh",
"*",
"C",
".",
"pam_handle_t",
",",
"flags",
",",
"argc",
"int",
",",
"argv",
"*",
"*",
"C",
".",
"char",
")",
"C",
".",
"int",
"{",
"C",
".",
"initLog",
"(",
")",
"\n",
"user",
":=",
"C",
".",
"get_use... | // nolint
//export pam_sm_open_session | [
"nolint",
"export",
"pam_sm_open_session"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/plugins/pam/uidmonitorpam.go#L55-L103 |
7,477 | aporeto-inc/trireme-lib | plugins/pam/uidmonitorpam.go | pam_sm_close_session | func pam_sm_close_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
slog.Alert("pam_sm_close_session") // nolint
slog.Close() // nolint
return C.PAM_SUCCESS
} | go | func pam_sm_close_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
slog.Alert("pam_sm_close_session") // nolint
slog.Close() // nolint
return C.PAM_SUCCESS
} | [
"func",
"pam_sm_close_session",
"(",
"pamh",
"*",
"C",
".",
"pam_handle_t",
",",
"flags",
",",
"argc",
"int",
",",
"argv",
"*",
"*",
"C",
".",
"char",
")",
"C",
".",
"int",
"{",
"slog",
",",
"_",
":=",
"syslog",
".",
"New",
"(",
"syslog",
".",
"L... | // nolint
//export pam_sm_close_session | [
"nolint",
"export",
"pam_sm_close_session"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/plugins/pam/uidmonitorpam.go#L107-L112 |
7,478 | aporeto-inc/trireme-lib | controller/internal/processmon/mockprocessmon/mockprocessmon.go | NewMockProcessManager | func NewMockProcessManager(ctrl *gomock.Controller) *MockProcessManager {
mock := &MockProcessManager{ctrl: ctrl}
mock.recorder = &MockProcessManagerMockRecorder{mock}
return mock
} | go | func NewMockProcessManager(ctrl *gomock.Controller) *MockProcessManager {
mock := &MockProcessManager{ctrl: ctrl}
mock.recorder = &MockProcessManagerMockRecorder{mock}
return mock
} | [
"func",
"NewMockProcessManager",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockProcessManager",
"{",
"mock",
":=",
"&",
"MockProcessManager",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockProcessManagerMockRecorder"... | // NewMockProcessManager creates a new mock instance
// nolint | [
"NewMockProcessManager",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L28-L32 |
7,479 | aporeto-inc/trireme-lib | controller/internal/processmon/mockprocessmon/mockprocessmon.go | KillRemoteEnforcer | func (m *MockProcessManager) KillRemoteEnforcer(contextID string, force bool) error {
ret := m.ctrl.Call(m, "KillRemoteEnforcer", contextID, force)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockProcessManager) KillRemoteEnforcer(contextID string, force bool) error {
ret := m.ctrl.Call(m, "KillRemoteEnforcer", contextID, force)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockProcessManager",
")",
"KillRemoteEnforcer",
"(",
"contextID",
"string",
",",
"force",
"bool",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"force",
")",
"... | // KillRemoteEnforcer mocks base method
// nolint | [
"KillRemoteEnforcer",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L42-L46 |
7,480 | aporeto-inc/trireme-lib | controller/internal/processmon/mockprocessmon/mockprocessmon.go | KillRemoteEnforcer | func (mr *MockProcessManagerMockRecorder) KillRemoteEnforcer(contextID, force interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KillRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).KillRemoteEnforcer), contextID, force)
} | go | func (mr *MockProcessManagerMockRecorder) KillRemoteEnforcer(contextID, force interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KillRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).KillRemoteEnforcer), contextID, force)
} | [
"func",
"(",
"mr",
"*",
"MockProcessManagerMockRecorder",
")",
"KillRemoteEnforcer",
"(",
"contextID",
",",
"force",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
... | // KillRemoteEnforcer indicates an expected call of KillRemoteEnforcer
// nolint | [
"KillRemoteEnforcer",
"indicates",
"an",
"expected",
"call",
"of",
"KillRemoteEnforcer",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L50-L52 |
7,481 | aporeto-inc/trireme-lib | controller/internal/processmon/mockprocessmon/mockprocessmon.go | LaunchRemoteEnforcer | func (m *MockProcessManager) LaunchRemoteEnforcer(contextID string, refPid int, refNsPath, arg, statssecret, procMountPoint string) (bool, error) {
ret := m.ctrl.Call(m, "LaunchRemoteEnforcer", contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockProcessManager) LaunchRemoteEnforcer(contextID string, refPid int, refNsPath, arg, statssecret, procMountPoint string) (bool, error) {
ret := m.ctrl.Call(m, "LaunchRemoteEnforcer", contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockProcessManager",
")",
"LaunchRemoteEnforcer",
"(",
"contextID",
"string",
",",
"refPid",
"int",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"ret",
... | // LaunchRemoteEnforcer mocks base method
// nolint | [
"LaunchRemoteEnforcer",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L56-L61 |
7,482 | aporeto-inc/trireme-lib | controller/internal/processmon/mockprocessmon/mockprocessmon.go | LaunchRemoteEnforcer | func (mr *MockProcessManagerMockRecorder) LaunchRemoteEnforcer(contextID, refPid, refNsPath, arg, statssecret, procMountPoint interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaunchRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).LaunchRemoteEnforcer), contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
} | go | func (mr *MockProcessManagerMockRecorder) LaunchRemoteEnforcer(contextID, refPid, refNsPath, arg, statssecret, procMountPoint interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaunchRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).LaunchRemoteEnforcer), contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
} | [
"func",
"(",
"mr",
"*",
"MockProcessManagerMockRecorder",
")",
"LaunchRemoteEnforcer",
"(",
"contextID",
",",
"refPid",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"retur... | // LaunchRemoteEnforcer indicates an expected call of LaunchRemoteEnforcer
// nolint | [
"LaunchRemoteEnforcer",
"indicates",
"an",
"expected",
"call",
"of",
"LaunchRemoteEnforcer",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L65-L67 |
7,483 | aporeto-inc/trireme-lib | controller/pkg/claimsheader/claimsheader.go | NewClaimsHeader | func NewClaimsHeader(opts ...Option) *ClaimsHeader {
c := &ClaimsHeader{}
for _, opt := range opts {
opt(c)
}
return c
} | go | func NewClaimsHeader(opts ...Option) *ClaimsHeader {
c := &ClaimsHeader{}
for _, opt := range opts {
opt(c)
}
return c
} | [
"func",
"NewClaimsHeader",
"(",
"opts",
"...",
"Option",
")",
"*",
"ClaimsHeader",
"{",
"c",
":=",
"&",
"ClaimsHeader",
"{",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"c",
"\... | // NewClaimsHeader returns claims header handler | [
"NewClaimsHeader",
"returns",
"claims",
"header",
"handler"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/claimsheader.go#L4-L13 |
7,484 | aporeto-inc/trireme-lib | controller/pkg/secrets/compactpki.go | NewCompactPKI | func NewCompactPKI(keyPEM []byte, certPEM []byte, caPEM []byte, txKey []byte, compress claimsheader.CompressionType) (*CompactPKI, error) {
zap.L().Warn("DEPRECATED. secrets.NewCompactPKI is deprecated in favor of secrets.NewCompactPKIWithTokenCA")
return NewCompactPKIWithTokenCA(keyPEM, certPEM, caPEM, [][]byte{caPEM}, txKey, compress)
} | go | func NewCompactPKI(keyPEM []byte, certPEM []byte, caPEM []byte, txKey []byte, compress claimsheader.CompressionType) (*CompactPKI, error) {
zap.L().Warn("DEPRECATED. secrets.NewCompactPKI is deprecated in favor of secrets.NewCompactPKIWithTokenCA")
return NewCompactPKIWithTokenCA(keyPEM, certPEM, caPEM, [][]byte{caPEM}, txKey, compress)
} | [
"func",
"NewCompactPKI",
"(",
"keyPEM",
"[",
"]",
"byte",
",",
"certPEM",
"[",
"]",
"byte",
",",
"caPEM",
"[",
"]",
"byte",
",",
"txKey",
"[",
"]",
"byte",
",",
"compress",
"claimsheader",
".",
"CompressionType",
")",
"(",
"*",
"CompactPKI",
",",
"erro... | // NewCompactPKI creates new secrets for PKI implementation based on compact encoding | [
"NewCompactPKI",
"creates",
"new",
"secrets",
"for",
"PKI",
"implementation",
"based",
"on",
"compact",
"encoding"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/secrets/compactpki.go#L32-L36 |
7,485 | aporeto-inc/trireme-lib | controller/pkg/secrets/compactpki.go | PublicSecrets | func (p *CompactPKI) PublicSecrets() PublicSecrets {
return &CompactPKIPublicSecrets{
Type: PKICompactType,
Key: p.PrivateKeyPEM,
Certificate: p.PublicKeyPEM,
CA: p.AuthorityPEM,
Token: p.txKey,
TokenCAs: p.TokenKeyPEMs,
Compressed: p.Compressed,
}
} | go | func (p *CompactPKI) PublicSecrets() PublicSecrets {
return &CompactPKIPublicSecrets{
Type: PKICompactType,
Key: p.PrivateKeyPEM,
Certificate: p.PublicKeyPEM,
CA: p.AuthorityPEM,
Token: p.txKey,
TokenCAs: p.TokenKeyPEMs,
Compressed: p.Compressed,
}
} | [
"func",
"(",
"p",
"*",
"CompactPKI",
")",
"PublicSecrets",
"(",
")",
"PublicSecrets",
"{",
"return",
"&",
"CompactPKIPublicSecrets",
"{",
"Type",
":",
"PKICompactType",
",",
"Key",
":",
"p",
".",
"PrivateKeyPEM",
",",
"Certificate",
":",
"p",
".",
"PublicKey... | // PublicSecrets returns the secrets that are marshallable over the RPC interface. | [
"PublicSecrets",
"returns",
"the",
"secrets",
"that",
"are",
"marshallable",
"over",
"the",
"RPC",
"interface",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/secrets/compactpki.go#L117-L127 |
7,486 | aporeto-inc/trireme-lib | policy/policy.go | NewPUPolicyWithDefaults | func NewPUPolicyWithDefaults() *PUPolicy {
return NewPUPolicy("", AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
} | go | func NewPUPolicyWithDefaults() *PUPolicy {
return NewPUPolicy("", AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
} | [
"func",
"NewPUPolicyWithDefaults",
"(",
")",
"*",
"PUPolicy",
"{",
"return",
"NewPUPolicy",
"(",
"\"",
"\"",
",",
"AllowAll",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"0",
",",
"nil",
",",... | // NewPUPolicyWithDefaults sets up a PU policy with defaults | [
"NewPUPolicyWithDefaults",
"sets",
"up",
"a",
"PU",
"policy",
"with",
"defaults"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L141-L143 |
7,487 | aporeto-inc/trireme-lib | policy/policy.go | ManagementID | func (p *PUPolicy) ManagementID() string {
p.Lock()
defer p.Unlock()
return p.managementID
} | go | func (p *PUPolicy) ManagementID() string {
p.Lock()
defer p.Unlock()
return p.managementID
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ManagementID",
"(",
")",
"string",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"managementID",
"\n",
"}"
] | // ManagementID returns the management ID | [
"ManagementID",
"returns",
"the",
"management",
"ID"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L171-L176 |
7,488 | aporeto-inc/trireme-lib | policy/policy.go | TriremeAction | func (p *PUPolicy) TriremeAction() PUAction {
p.Lock()
defer p.Unlock()
return p.triremeAction
} | go | func (p *PUPolicy) TriremeAction() PUAction {
p.Lock()
defer p.Unlock()
return p.triremeAction
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"TriremeAction",
"(",
")",
"PUAction",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"triremeAction",
"\n",
"}"
] | // TriremeAction returns the TriremeAction | [
"TriremeAction",
"returns",
"the",
"TriremeAction"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L179-L184 |
7,489 | aporeto-inc/trireme-lib | policy/policy.go | SetTriremeAction | func (p *PUPolicy) SetTriremeAction(action PUAction) {
p.Lock()
defer p.Unlock()
p.triremeAction = action
} | go | func (p *PUPolicy) SetTriremeAction(action PUAction) {
p.Lock()
defer p.Unlock()
p.triremeAction = action
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"SetTriremeAction",
"(",
"action",
"PUAction",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"triremeAction",
"=",
"action",
"\n",
"}"
] | // SetTriremeAction returns the TriremeAction | [
"SetTriremeAction",
"returns",
"the",
"TriremeAction"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L187-L192 |
7,490 | aporeto-inc/trireme-lib | policy/policy.go | ApplicationACLs | func (p *PUPolicy) ApplicationACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.applicationACLs.Copy()
} | go | func (p *PUPolicy) ApplicationACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.applicationACLs.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ApplicationACLs",
"(",
")",
"IPRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"applicationACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // ApplicationACLs returns a copy of IPRuleList | [
"ApplicationACLs",
"returns",
"a",
"copy",
"of",
"IPRuleList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L195-L200 |
7,491 | aporeto-inc/trireme-lib | policy/policy.go | NetworkACLs | func (p *PUPolicy) NetworkACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.networkACLs.Copy()
} | go | func (p *PUPolicy) NetworkACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.networkACLs.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"NetworkACLs",
"(",
")",
"IPRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"networkACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // NetworkACLs returns a copy of IPRuleList | [
"NetworkACLs",
"returns",
"a",
"copy",
"of",
"IPRuleList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L203-L208 |
7,492 | aporeto-inc/trireme-lib | policy/policy.go | DNSNameACLs | func (p *PUPolicy) DNSNameACLs() DNSRuleList {
p.Lock()
defer p.Unlock()
return p.DNSACLs.Copy()
} | go | func (p *PUPolicy) DNSNameACLs() DNSRuleList {
p.Lock()
defer p.Unlock()
return p.DNSACLs.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"DNSNameACLs",
"(",
")",
"DNSRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"DNSACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // DNSNameACLs returns a copy of DNSRuleList | [
"DNSNameACLs",
"returns",
"a",
"copy",
"of",
"DNSRuleList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L211-L216 |
7,493 | aporeto-inc/trireme-lib | policy/policy.go | ReceiverRules | func (p *PUPolicy) ReceiverRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.receiverRules.Copy()
} | go | func (p *PUPolicy) ReceiverRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.receiverRules.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ReceiverRules",
"(",
")",
"TagSelectorList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"receiverRules",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // ReceiverRules returns a copy of TagSelectorList | [
"ReceiverRules",
"returns",
"a",
"copy",
"of",
"TagSelectorList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L219-L224 |
7,494 | aporeto-inc/trireme-lib | policy/policy.go | AddReceiverRules | func (p *PUPolicy) AddReceiverRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.receiverRules = append(p.receiverRules, t)
} | go | func (p *PUPolicy) AddReceiverRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.receiverRules = append(p.receiverRules, t)
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddReceiverRules",
"(",
"t",
"TagSelector",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"receiverRules",
"=",
"append",
"(",
"p",
".",
"receiverRules",
... | // AddReceiverRules adds a receiver rule | [
"AddReceiverRules",
"adds",
"a",
"receiver",
"rule"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L227-L232 |
7,495 | aporeto-inc/trireme-lib | policy/policy.go | TransmitterRules | func (p *PUPolicy) TransmitterRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.transmitterRules.Copy()
} | go | func (p *PUPolicy) TransmitterRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.transmitterRules.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"TransmitterRules",
"(",
")",
"TagSelectorList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"transmitterRules",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // TransmitterRules returns a copy of TagSelectorList | [
"TransmitterRules",
"returns",
"a",
"copy",
"of",
"TagSelectorList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L235-L240 |
7,496 | aporeto-inc/trireme-lib | policy/policy.go | AddTransmitterRules | func (p *PUPolicy) AddTransmitterRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.transmitterRules = append(p.transmitterRules, t)
} | go | func (p *PUPolicy) AddTransmitterRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.transmitterRules = append(p.transmitterRules, t)
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddTransmitterRules",
"(",
"t",
"TagSelector",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"transmitterRules",
"=",
"append",
"(",
"p",
".",
"transmitte... | // AddTransmitterRules adds a transmitter rule | [
"AddTransmitterRules",
"adds",
"a",
"transmitter",
"rule"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L243-L248 |
7,497 | aporeto-inc/trireme-lib | policy/policy.go | Identity | func (p *PUPolicy) Identity() *TagStore {
p.Lock()
defer p.Unlock()
return p.identity.Copy()
} | go | func (p *PUPolicy) Identity() *TagStore {
p.Lock()
defer p.Unlock()
return p.identity.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"Identity",
"(",
")",
"*",
"TagStore",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"identity",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // Identity returns a copy of the Identity | [
"Identity",
"returns",
"a",
"copy",
"of",
"the",
"Identity"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L251-L256 |
7,498 | aporeto-inc/trireme-lib | policy/policy.go | Annotations | func (p *PUPolicy) Annotations() *TagStore {
p.Lock()
defer p.Unlock()
return p.annotations.Copy()
} | go | func (p *PUPolicy) Annotations() *TagStore {
p.Lock()
defer p.Unlock()
return p.annotations.Copy()
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"Annotations",
"(",
")",
"*",
"TagStore",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"annotations",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // Annotations returns a copy of the annotations | [
"Annotations",
"returns",
"a",
"copy",
"of",
"the",
"annotations"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L259-L264 |
7,499 | aporeto-inc/trireme-lib | policy/policy.go | AddIdentityTag | func (p *PUPolicy) AddIdentityTag(k, v string) {
p.Lock()
defer p.Unlock()
p.identity.AppendKeyValue(k, v)
} | go | func (p *PUPolicy) AddIdentityTag(k, v string) {
p.Lock()
defer p.Unlock()
p.identity.AppendKeyValue(k, v)
} | [
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddIdentityTag",
"(",
"k",
",",
"v",
"string",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"identity",
".",
"AppendKeyValue",
"(",
"k",
",",
"v",
... | // AddIdentityTag adds a policy tag | [
"AddIdentityTag",
"adds",
"a",
"policy",
"tag"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L267-L272 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.