id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,900 | aporeto-inc/trireme-lib | policy/types.go | EncodedActionString | func (f *FlowPolicy) EncodedActionString() string {
var e string
if f.Action.Accepted() && !f.Action.Rejected() {
if f.ObserveAction.ObserveContinue() {
e = "1"
} else if f.ObserveAction.ObserveApply() {
e = "2"
} else {
e = "3"
}
} else if !f.Action.Accepted() && f.Action.Rejected() {
if f.ObserveAction.ObserveContinue() {
e = "4"
} else if f.ObserveAction.ObserveApply() {
e = "5"
} else {
e = "6"
}
} else {
if f.ObserveAction.ObserveContinue() {
e = "7"
} else if f.ObserveAction.ObserveApply() {
e = "8"
} else {
e = "9"
}
}
return e
} | go | func (f *FlowPolicy) EncodedActionString() string {
var e string
if f.Action.Accepted() && !f.Action.Rejected() {
if f.ObserveAction.ObserveContinue() {
e = "1"
} else if f.ObserveAction.ObserveApply() {
e = "2"
} else {
e = "3"
}
} else if !f.Action.Accepted() && f.Action.Rejected() {
if f.ObserveAction.ObserveContinue() {
e = "4"
} else if f.ObserveAction.ObserveApply() {
e = "5"
} else {
e = "6"
}
} else {
if f.ObserveAction.ObserveContinue() {
e = "7"
} else if f.ObserveAction.ObserveApply() {
e = "8"
} else {
e = "9"
}
}
return e
} | [
"func",
"(",
"f",
"*",
"FlowPolicy",
")",
"EncodedActionString",
"(",
")",
"string",
"{",
"var",
"e",
"string",
"\n\n",
"if",
"f",
".",
"Action",
".",
"Accepted",
"(",
")",
"&&",
"!",
"f",
".",
"Action",
".",
"Rejected",
"(",
")",
"{",
"if",
"f",
... | // EncodedActionString is used to encode observed action as well as action | [
"EncodedActionString",
"is",
"used",
"to",
"encode",
"observed",
"action",
"as",
"well",
"as",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L181-L211 |
6,901 | aporeto-inc/trireme-lib | policy/types.go | EncodedStringToAction | func EncodedStringToAction(e string) (ActionType, ObserveActionType, error) {
switch e {
case "1":
return Observe | Accept, ObserveContinue, nil
case "2":
return Observe | Accept, ObserveApply, nil
case "3":
return Accept, ObserveNone, nil
case "4":
return Observe | Reject, ObserveContinue, nil
case "5":
return Observe | Reject, ObserveApply, nil
case "6":
return Reject, ObserveNone, nil
case "7":
return Observe, ObserveContinue, nil
case "8":
return Observe, ObserveApply, nil
case "9":
return 0, ObserveNone, nil
}
return 0, 0, errors.New("Invalid encoding")
} | go | func EncodedStringToAction(e string) (ActionType, ObserveActionType, error) {
switch e {
case "1":
return Observe | Accept, ObserveContinue, nil
case "2":
return Observe | Accept, ObserveApply, nil
case "3":
return Accept, ObserveNone, nil
case "4":
return Observe | Reject, ObserveContinue, nil
case "5":
return Observe | Reject, ObserveApply, nil
case "6":
return Reject, ObserveNone, nil
case "7":
return Observe, ObserveContinue, nil
case "8":
return Observe, ObserveApply, nil
case "9":
return 0, ObserveNone, nil
}
return 0, 0, errors.New("Invalid encoding")
} | [
"func",
"EncodedStringToAction",
"(",
"e",
"string",
")",
"(",
"ActionType",
",",
"ObserveActionType",
",",
"error",
")",
"{",
"switch",
"e",
"{",
"case",
"\"",
"\"",
":",
"return",
"Observe",
"|",
"Accept",
",",
"ObserveContinue",
",",
"nil",
"\n",
"case"... | // EncodedStringToAction returns action and observed action from encoded string. | [
"EncodedStringToAction",
"returns",
"action",
"and",
"observed",
"action",
"from",
"encoded",
"string",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L214-L238 |
6,902 | aporeto-inc/trireme-lib | policy/types.go | Copy | func (l DNSRuleList) Copy() DNSRuleList {
list := make(DNSRuleList, len(l))
for i, v := range l {
list[i] = v
}
return list
} | go | func (l DNSRuleList) Copy() DNSRuleList {
list := make(DNSRuleList, len(l))
for i, v := range l {
list[i] = v
}
return list
} | [
"func",
"(",
"l",
"DNSRuleList",
")",
"Copy",
"(",
")",
"DNSRuleList",
"{",
"list",
":=",
"make",
"(",
"DNSRuleList",
",",
"len",
"(",
"l",
")",
")",
"\n\n",
"for",
"i",
",",
"v",
":=",
"range",
"l",
"{",
"list",
"[",
"i",
"]",
"=",
"v",
"\n",
... | // Copy creates a clone of DNS rule list | [
"Copy",
"creates",
"a",
"clone",
"of",
"DNS",
"rule",
"list"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L264-L272 |
6,903 | aporeto-inc/trireme-lib | policy/types.go | Copy | func (l IPRuleList) Copy() IPRuleList {
list := make(IPRuleList, len(l))
for i, v := range l {
list[i] = v
}
return list
} | go | func (l IPRuleList) Copy() IPRuleList {
list := make(IPRuleList, len(l))
for i, v := range l {
list[i] = v
}
return list
} | [
"func",
"(",
"l",
"IPRuleList",
")",
"Copy",
"(",
")",
"IPRuleList",
"{",
"list",
":=",
"make",
"(",
"IPRuleList",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"l",
"{",
"list",
"[",
"i",
"]",
"=",
"v",
"\n",
"}"... | // Copy creates a clone of the IP rule list | [
"Copy",
"creates",
"a",
"clone",
"of",
"the",
"IP",
"rule",
"list"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L275-L281 |
6,904 | aporeto-inc/trireme-lib | policy/types.go | Copy | func (t TagSelectorList) Copy() TagSelectorList {
list := make(TagSelectorList, len(t))
for i, v := range t {
list[i] = v
}
return list
} | go | func (t TagSelectorList) Copy() TagSelectorList {
list := make(TagSelectorList, len(t))
for i, v := range t {
list[i] = v
}
return list
} | [
"func",
"(",
"t",
"TagSelectorList",
")",
"Copy",
"(",
")",
"TagSelectorList",
"{",
"list",
":=",
"make",
"(",
"TagSelectorList",
",",
"len",
"(",
"t",
")",
")",
"\n\n",
"for",
"i",
",",
"v",
":=",
"range",
"t",
"{",
"list",
"[",
"i",
"]",
"=",
"... | // Copy returns a copy of the TagSelectorList | [
"Copy",
"returns",
"a",
"copy",
"of",
"the",
"TagSelectorList"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L301-L309 |
6,905 | aporeto-inc/trireme-lib | policy/types.go | Copy | func (s ExtendedMap) Copy() ExtendedMap {
c := ExtendedMap{}
for k, v := range s {
c[k] = v
}
return c
} | go | func (s ExtendedMap) Copy() ExtendedMap {
c := ExtendedMap{}
for k, v := range s {
c[k] = v
}
return c
} | [
"func",
"(",
"s",
"ExtendedMap",
")",
"Copy",
"(",
")",
"ExtendedMap",
"{",
"c",
":=",
"ExtendedMap",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"s",
"{",
"c",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"return",
"c",
"\n",
"}"
] | // Copy copies an ExtendedMap | [
"Copy",
"copies",
"an",
"ExtendedMap"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L315-L321 |
6,906 | aporeto-inc/trireme-lib | policy/types.go | Get | func (s ExtendedMap) Get(key string) (string, bool) {
value, ok := s[key]
return value, ok
} | go | func (s ExtendedMap) Get(key string) (string, bool) {
value, ok := s[key]
return value, ok
} | [
"func",
"(",
"s",
"ExtendedMap",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"value",
",",
"ok",
":=",
"s",
"[",
"key",
"]",
"\n",
"return",
"value",
",",
"ok",
"\n",
"}"
] | // Get does a lookup in the map | [
"Get",
"does",
"a",
"lookup",
"in",
"the",
"map"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/types.go#L324-L327 |
6,907 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/remoteenforcer_stub.go | newRemoteEnforcer | func newRemoteEnforcer(
ctx context.Context,
cancel context.CancelFunc,
service packetprocessor.PacketProcessor,
rpcHandle rpcwrapper.RPCServer,
secret string,
statsClient statsclient.StatsClient,
collector statscollector.Collector,
debugClient debugclient.DebugClient,
) (*RemoteEnforcer, error) {
return nil, nil
} | go | func newRemoteEnforcer(
ctx context.Context,
cancel context.CancelFunc,
service packetprocessor.PacketProcessor,
rpcHandle rpcwrapper.RPCServer,
secret string,
statsClient statsclient.StatsClient,
collector statscollector.Collector,
debugClient debugclient.DebugClient,
) (*RemoteEnforcer, error) {
return nil, nil
} | [
"func",
"newRemoteEnforcer",
"(",
"ctx",
"context",
".",
"Context",
",",
"cancel",
"context",
".",
"CancelFunc",
",",
"service",
"packetprocessor",
".",
"PacketProcessor",
",",
"rpcHandle",
"rpcwrapper",
".",
"RPCServer",
",",
"secret",
"string",
",",
"statsClient... | // newServer is a fake implementation for building on darwin. | [
"newServer",
"is",
"a",
"fake",
"implementation",
"for",
"building",
"on",
"darwin",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/remoteenforcer_stub.go#L24-L35 |
6,908 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | NewSecretsProxy | func NewSecretsProxy() *SecretsProxy {
return &SecretsProxy{
socketPath: constants.DefaultSecretsPath,
drivers: cache.NewCache("secrets driver cache"),
apiCacheMapping: cache.NewCache("secrets api cache"),
cgroupCache: cache.NewCache("secrets pu cache"),
policyCache: cache.NewCache("policy cache"),
}
} | go | func NewSecretsProxy() *SecretsProxy {
return &SecretsProxy{
socketPath: constants.DefaultSecretsPath,
drivers: cache.NewCache("secrets driver cache"),
apiCacheMapping: cache.NewCache("secrets api cache"),
cgroupCache: cache.NewCache("secrets pu cache"),
policyCache: cache.NewCache("policy cache"),
}
} | [
"func",
"NewSecretsProxy",
"(",
")",
"*",
"SecretsProxy",
"{",
"return",
"&",
"SecretsProxy",
"{",
"socketPath",
":",
"constants",
".",
"DefaultSecretsPath",
",",
"drivers",
":",
"cache",
".",
"NewCache",
"(",
"\"",
"\"",
")",
",",
"apiCacheMapping",
":",
"c... | // NewSecretsProxy creates a new secrets proxy. | [
"NewSecretsProxy",
"creates",
"a",
"new",
"secrets",
"proxy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L41-L50 |
6,909 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | Run | func (s *SecretsProxy) Run(ctx context.Context) error {
s.Lock()
defer s.Unlock()
var err error
// Start a custom listener
addr, _ := net.ResolveUnixAddr("unix", s.socketPath)
nl, err := net.ListenUnix("unix", addr)
if err != nil {
return fmt.Errorf("Unable to start API server: %s", err)
}
s.server = &http.Server{
Handler: http.HandlerFunc(s.apiProcessor),
}
go func() {
<-ctx.Done()
s.server.Close() // nolint errcheck
}()
go s.server.Serve(server.NewUIDListener(nl)) // nolint errcheck
return nil
} | go | func (s *SecretsProxy) Run(ctx context.Context) error {
s.Lock()
defer s.Unlock()
var err error
// Start a custom listener
addr, _ := net.ResolveUnixAddr("unix", s.socketPath)
nl, err := net.ListenUnix("unix", addr)
if err != nil {
return fmt.Errorf("Unable to start API server: %s", err)
}
s.server = &http.Server{
Handler: http.HandlerFunc(s.apiProcessor),
}
go func() {
<-ctx.Done()
s.server.Close() // nolint errcheck
}()
go s.server.Serve(server.NewUIDListener(nl)) // nolint errcheck
return nil
} | [
"func",
"(",
"s",
"*",
"SecretsProxy",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n\n",
"// Start a custom listener",
... | // Run implements the run method of the CtrlInterface. It starts the proxy
// server and initializes the data structures. | [
"Run",
"implements",
"the",
"run",
"method",
"of",
"the",
"CtrlInterface",
".",
"It",
"starts",
"the",
"proxy",
"server",
"and",
"initializes",
"the",
"data",
"structures",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L54-L79 |
6,910 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | Enforce | func (s *SecretsProxy) Enforce(puInfo *policy.PUInfo) error {
return s.updateService(puInfo)
} | go | func (s *SecretsProxy) Enforce(puInfo *policy.PUInfo) error {
return s.updateService(puInfo)
} | [
"func",
"(",
"s",
"*",
"SecretsProxy",
")",
"Enforce",
"(",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"return",
"s",
".",
"updateService",
"(",
"puInfo",
")",
"\n",
"}"
] | // Enforce implements the corresponding interface of enforcers. | [
"Enforce",
"implements",
"the",
"corresponding",
"interface",
"of",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L82-L84 |
6,911 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | apiProcessor | func (s *SecretsProxy) apiProcessor(w http.ResponseWriter, r *http.Request) {
zap.L().Info("Processing secrets call",
zap.String("URI", r.RequestURI),
zap.String("Host", r.Host),
zap.String("Remote address", r.RemoteAddr),
)
// The remote address will contain the uid, gid and pid of the calling process.
// This is because of the specific socket listener we are uing.
parts := strings.Split(r.RemoteAddr, ":")
if len(parts) != 3 {
httpError(w, fmt.Errorf("Bad Remote Address"), "Unauthorized request", http.StatusUnauthorized)
return
}
// We only care about the originating PID.
pid := parts[2]
cgroup, err := findParentCgroup(pid)
if err != nil {
httpError(w, err, "Unauthorized client - not the first process", http.StatusUnauthorized)
return
}
data, err := s.apiCacheMapping.Get(cgroup)
if err != nil {
httpError(w, err, "Unauthorized client", http.StatusUnauthorized)
return
}
// Find the corresponding API cache with the access permissions for
// this particular client.
apiCache, ok := data.(*urisearch.APICache)
if !ok {
httpError(w, fmt.Errorf("Invalid data types"), "Internal server error - invalid type", http.StatusInternalServerError)
return
}
// Find the identity of the PU
policyData, err := s.policyCache.Get(cgroup)
if err != nil {
httpError(w, err, "Unauthorized client", http.StatusUnauthorized)
return
}
scopes, ok := policyData.([]string)
if !ok {
httpError(w, fmt.Errorf("Invalid data types"), "Internal server error - invalid type", http.StatusInternalServerError)
return
}
// Search the API cache for matching rules.
found, _ := apiCache.FindAndMatchScope(r.Method, r.RequestURI, scopes)
if !found {
httpError(w, fmt.Errorf("Unauthorized service"), "Unauthorized access", http.StatusUnauthorized)
return
}
// Retrieve the secrets driver data and information.
driverData, err := s.drivers.Get(cgroup)
if err != nil {
httpError(w, err, "No secrets driver for this client", http.StatusBadRequest)
return
}
driver, ok := driverData.(SecretsDriver)
if !ok {
httpError(w, fmt.Errorf("driver not found"), "Bad driver", http.StatusInternalServerError)
return
}
// Transfor the request based on the driver.
if err := driver.Transform(r); err != nil {
httpError(w, err, "Secrets driver error", http.StatusInternalServerError)
return
}
// Forward the request. TODO .. we need to massage the return here.
forwarder, err := forward.New(forward.RoundTripper(driver.Transport()))
if err != nil {
httpError(w, err, "Failed to configure forwarder", http.StatusInternalServerError)
return
}
forwarder.ServeHTTP(w, r)
} | go | func (s *SecretsProxy) apiProcessor(w http.ResponseWriter, r *http.Request) {
zap.L().Info("Processing secrets call",
zap.String("URI", r.RequestURI),
zap.String("Host", r.Host),
zap.String("Remote address", r.RemoteAddr),
)
// The remote address will contain the uid, gid and pid of the calling process.
// This is because of the specific socket listener we are uing.
parts := strings.Split(r.RemoteAddr, ":")
if len(parts) != 3 {
httpError(w, fmt.Errorf("Bad Remote Address"), "Unauthorized request", http.StatusUnauthorized)
return
}
// We only care about the originating PID.
pid := parts[2]
cgroup, err := findParentCgroup(pid)
if err != nil {
httpError(w, err, "Unauthorized client - not the first process", http.StatusUnauthorized)
return
}
data, err := s.apiCacheMapping.Get(cgroup)
if err != nil {
httpError(w, err, "Unauthorized client", http.StatusUnauthorized)
return
}
// Find the corresponding API cache with the access permissions for
// this particular client.
apiCache, ok := data.(*urisearch.APICache)
if !ok {
httpError(w, fmt.Errorf("Invalid data types"), "Internal server error - invalid type", http.StatusInternalServerError)
return
}
// Find the identity of the PU
policyData, err := s.policyCache.Get(cgroup)
if err != nil {
httpError(w, err, "Unauthorized client", http.StatusUnauthorized)
return
}
scopes, ok := policyData.([]string)
if !ok {
httpError(w, fmt.Errorf("Invalid data types"), "Internal server error - invalid type", http.StatusInternalServerError)
return
}
// Search the API cache for matching rules.
found, _ := apiCache.FindAndMatchScope(r.Method, r.RequestURI, scopes)
if !found {
httpError(w, fmt.Errorf("Unauthorized service"), "Unauthorized access", http.StatusUnauthorized)
return
}
// Retrieve the secrets driver data and information.
driverData, err := s.drivers.Get(cgroup)
if err != nil {
httpError(w, err, "No secrets driver for this client", http.StatusBadRequest)
return
}
driver, ok := driverData.(SecretsDriver)
if !ok {
httpError(w, fmt.Errorf("driver not found"), "Bad driver", http.StatusInternalServerError)
return
}
// Transfor the request based on the driver.
if err := driver.Transform(r); err != nil {
httpError(w, err, "Secrets driver error", http.StatusInternalServerError)
return
}
// Forward the request. TODO .. we need to massage the return here.
forwarder, err := forward.New(forward.RoundTripper(driver.Transport()))
if err != nil {
httpError(w, err, "Failed to configure forwarder", http.StatusInternalServerError)
return
}
forwarder.ServeHTTP(w, r)
} | [
"func",
"(",
"s",
"*",
"SecretsProxy",
")",
"apiProcessor",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Info",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
... | // apiProcessor is called for every request. It processes the request
// and forwards to the originator of the secrets service after
// authenticating that the client can access the service. | [
"apiProcessor",
"is",
"called",
"for",
"every",
"request",
".",
"It",
"processes",
"the",
"request",
"and",
"forwards",
"to",
"the",
"originator",
"of",
"the",
"secrets",
"service",
"after",
"authenticating",
"that",
"the",
"client",
"can",
"access",
"the",
"s... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L105-L188 |
6,912 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | ValidateOriginProcess | func ValidateOriginProcess(pid string) (string, error) {
pidNumber, err := strconv.Atoi(pid)
if err != nil {
return "", fmt.Errorf("Invalid PID %s", pid)
}
process, err := process.NewProcess(int32(pidNumber))
if err != nil {
return "", fmt.Errorf("Process not found: %s", err)
}
ppid, err := process.Ppid()
if err != nil {
return "", fmt.Errorf("Parent process not found: %s", err)
}
parentPidCgroup, err := processCgroups(strconv.Itoa(int(ppid)), "net_cls,net_prio")
if err != nil {
return "", fmt.Errorf("Parent cgroup not found: %s", err)
}
if parentPidCgroup != "/" {
return "", fmt.Errorf("Parent is not root cgroup - authorization fail")
}
return findParentCgroup(pid)
} | go | func ValidateOriginProcess(pid string) (string, error) {
pidNumber, err := strconv.Atoi(pid)
if err != nil {
return "", fmt.Errorf("Invalid PID %s", pid)
}
process, err := process.NewProcess(int32(pidNumber))
if err != nil {
return "", fmt.Errorf("Process not found: %s", err)
}
ppid, err := process.Ppid()
if err != nil {
return "", fmt.Errorf("Parent process not found: %s", err)
}
parentPidCgroup, err := processCgroups(strconv.Itoa(int(ppid)), "net_cls,net_prio")
if err != nil {
return "", fmt.Errorf("Parent cgroup not found: %s", err)
}
if parentPidCgroup != "/" {
return "", fmt.Errorf("Parent is not root cgroup - authorization fail")
}
return findParentCgroup(pid)
} | [
"func",
"ValidateOriginProcess",
"(",
"pid",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"pidNumber",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"pid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"... | // ValidateOriginProcess implements a strict validation of the origin process. We might add later. | [
"ValidateOriginProcess",
"implements",
"a",
"strict",
"validation",
"of",
"the",
"origin",
"process",
".",
"We",
"might",
"add",
"later",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L262-L284 |
6,913 | aporeto-inc/trireme-lib | controller/internal/enforcer/secretsproxy/secretsproxy.go | findParentCgroup | func findParentCgroup(pid string) (string, error) {
cgroup, err := processCgroups(pid, "net_cls,net_prio")
if err != nil {
return "", fmt.Errorf("Invalid cgroup: %s", err)
}
for i := len(cgroup) - 1; i > 0; i-- {
if cgroup[i:i+1] == "/" {
return cgroup[:i], nil
}
}
if strings.HasPrefix(cgroup, "/docker/") && len(cgroup) > 8 {
return cgroup[8:20], nil
}
return "", fmt.Errorf("Cannot find parent cgroup: %s", pid)
} | go | func findParentCgroup(pid string) (string, error) {
cgroup, err := processCgroups(pid, "net_cls,net_prio")
if err != nil {
return "", fmt.Errorf("Invalid cgroup: %s", err)
}
for i := len(cgroup) - 1; i > 0; i-- {
if cgroup[i:i+1] == "/" {
return cgroup[:i], nil
}
}
if strings.HasPrefix(cgroup, "/docker/") && len(cgroup) > 8 {
return cgroup[8:20], nil
}
return "", fmt.Errorf("Cannot find parent cgroup: %s", pid)
} | [
"func",
"findParentCgroup",
"(",
"pid",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"cgroup",
",",
"err",
":=",
"processCgroups",
"(",
"pid",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
"."... | // findParentCgroup returns the parent cgroup of the process caller | [
"findParentCgroup",
"returns",
"the",
"parent",
"cgroup",
"of",
"the",
"process",
"caller"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/secretsproxy/secretsproxy.go#L314-L329 |
6,914 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | NewSupervisor | func NewSupervisor(
collector collector.EventCollector,
enforcerInstance enforcer.Enforcer,
mode constants.ModeType,
cfg *runtime.Configuration,
p packetprocessor.PacketProcessor,
) (Supervisor, error) {
if collector == nil || enforcerInstance == nil {
return nil, errors.New("Invalid parameters")
}
filterQueue := enforcerInstance.GetFilterQueue()
if filterQueue == nil {
return nil, errors.New("enforcer filter queues cannot be nil")
}
impl, err := iptablesctrl.NewInstance(filterQueue, mode, cfg)
if err != nil {
return nil, fmt.Errorf("unable to initialize supervisor controllers: %s", err)
}
return &Config{
mode: mode,
impl: impl,
versionTracker: cache.NewCache("SupVersionTracker"),
collector: collector,
filterQueue: filterQueue,
service: p,
cfg: cfg,
}, nil
} | go | func NewSupervisor(
collector collector.EventCollector,
enforcerInstance enforcer.Enforcer,
mode constants.ModeType,
cfg *runtime.Configuration,
p packetprocessor.PacketProcessor,
) (Supervisor, error) {
if collector == nil || enforcerInstance == nil {
return nil, errors.New("Invalid parameters")
}
filterQueue := enforcerInstance.GetFilterQueue()
if filterQueue == nil {
return nil, errors.New("enforcer filter queues cannot be nil")
}
impl, err := iptablesctrl.NewInstance(filterQueue, mode, cfg)
if err != nil {
return nil, fmt.Errorf("unable to initialize supervisor controllers: %s", err)
}
return &Config{
mode: mode,
impl: impl,
versionTracker: cache.NewCache("SupVersionTracker"),
collector: collector,
filterQueue: filterQueue,
service: p,
cfg: cfg,
}, nil
} | [
"func",
"NewSupervisor",
"(",
"collector",
"collector",
".",
"EventCollector",
",",
"enforcerInstance",
"enforcer",
".",
"Enforcer",
",",
"mode",
"constants",
".",
"ModeType",
",",
"cfg",
"*",
"runtime",
".",
"Configuration",
",",
"p",
"packetprocessor",
".",
"P... | // NewSupervisor will create a new connection supervisor that uses IPTables
// to redirect specific packets to userspace. It instantiates multiple data stores
// to maintain efficient mappings between contextID, policy and IP addresses. This
// simplifies the lookup operations at the expense of memory. | [
"NewSupervisor",
"will",
"create",
"a",
"new",
"connection",
"supervisor",
"that",
"uses",
"IPTables",
"to",
"redirect",
"specific",
"packets",
"to",
"userspace",
".",
"It",
"instantiates",
"multiple",
"data",
"stores",
"to",
"maintain",
"efficient",
"mappings",
"... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L58-L89 |
6,915 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | Run | func (s *Config) Run(ctx context.Context) error {
s.Lock()
defer s.Unlock()
if err := s.impl.Run(ctx); err != nil {
return fmt.Errorf("unable to start the implementer: %s", err)
}
if err := s.impl.SetTargetNetworks(s.cfg); err != nil {
return err
}
if s.service != nil {
s.service.Initialize(s.filterQueue, s.impl.ACLProvider())
}
return nil
} | go | func (s *Config) Run(ctx context.Context) error {
s.Lock()
defer s.Unlock()
if err := s.impl.Run(ctx); err != nil {
return fmt.Errorf("unable to start the implementer: %s", err)
}
if err := s.impl.SetTargetNetworks(s.cfg); err != nil {
return err
}
if s.service != nil {
s.service.Initialize(s.filterQueue, s.impl.ACLProvider())
}
return nil
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"err",
":=",
"s",
".",
"impl",
".",
"Run",
"(",
"ctx... | // Run starts the supervisor | [
"Run",
"starts",
"the",
"supervisor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L92-L110 |
6,916 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | Supervise | func (s *Config) Supervise(contextID string, pu *policy.PUInfo) error {
if pu == nil || pu.Policy == nil || pu.Runtime == nil {
return errors.New("Invalid PU or policy info")
}
_, err := s.versionTracker.Get(contextID)
if err != nil {
// ContextID is not found in Cache, New PU: Do create.
return s.doCreatePU(contextID, pu)
}
// Context already in the cache. Just run update
return s.doUpdatePU(contextID, pu)
} | go | func (s *Config) Supervise(contextID string, pu *policy.PUInfo) error {
if pu == nil || pu.Policy == nil || pu.Runtime == nil {
return errors.New("Invalid PU or policy info")
}
_, err := s.versionTracker.Get(contextID)
if err != nil {
// ContextID is not found in Cache, New PU: Do create.
return s.doCreatePU(contextID, pu)
}
// Context already in the cache. Just run update
return s.doUpdatePU(contextID, pu)
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"Supervise",
"(",
"contextID",
"string",
",",
"pu",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"if",
"pu",
"==",
"nil",
"||",
"pu",
".",
"Policy",
"==",
"nil",
"||",
"pu",
".",
"Runtime",
"==",
"nil",
"... | // Supervise creates a mapping between an IP address and the corresponding labels.
// it invokes the various handlers that process the parameter policy. | [
"Supervise",
"creates",
"a",
"mapping",
"between",
"an",
"IP",
"address",
"and",
"the",
"corresponding",
"labels",
".",
"it",
"invokes",
"the",
"various",
"handlers",
"that",
"process",
"the",
"parameter",
"policy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L114-L128 |
6,917 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | Unsupervise | func (s *Config) Unsupervise(contextID string) error {
s.Lock()
defer s.Unlock()
data, err := s.versionTracker.Get(contextID)
if err != nil {
return fmt.Errorf("cannot find policy version: %s", err)
}
cfg := data.(*cacheData)
port := cfg.containerInfo.Policy.ServicesListeningPort()
// If local server, delete pu specific chains in Trireme/NetworkSvc/Hostmode chains.
puType := cfg.containerInfo.Runtime.PUType()
// TODO (varks): Similar to configureRules and UpdateRules, DeleteRules should take
// only contextID and *policy.PUInfo as function parameters.
if err := s.impl.DeleteRules(cfg.version, contextID, cfg.tcpPorts, cfg.udpPorts, cfg.mark, cfg.username, port, puType); err != nil {
zap.L().Warn("Some rules were not deleted during unsupervise", zap.Error(err))
}
if err := s.versionTracker.Remove(contextID); err != nil {
zap.L().Warn("Failed to clean the rule version cache", zap.Error(err))
}
return nil
} | go | func (s *Config) Unsupervise(contextID string) error {
s.Lock()
defer s.Unlock()
data, err := s.versionTracker.Get(contextID)
if err != nil {
return fmt.Errorf("cannot find policy version: %s", err)
}
cfg := data.(*cacheData)
port := cfg.containerInfo.Policy.ServicesListeningPort()
// If local server, delete pu specific chains in Trireme/NetworkSvc/Hostmode chains.
puType := cfg.containerInfo.Runtime.PUType()
// TODO (varks): Similar to configureRules and UpdateRules, DeleteRules should take
// only contextID and *policy.PUInfo as function parameters.
if err := s.impl.DeleteRules(cfg.version, contextID, cfg.tcpPorts, cfg.udpPorts, cfg.mark, cfg.username, port, puType); err != nil {
zap.L().Warn("Some rules were not deleted during unsupervise", zap.Error(err))
}
if err := s.versionTracker.Remove(contextID); err != nil {
zap.L().Warn("Failed to clean the rule version cache", zap.Error(err))
}
return nil
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"Unsupervise",
"(",
"contextID",
"string",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"data",
",",
"err",
":=",
"s",
".",
"versionTracker",
".",
"Get",
... | // Unsupervise removes the mapping from cache and cleans up the iptable rules. ALL
// remove operations will print errors by they don't return error. We want to force
// as much cleanup as possible to avoid stale state | [
"Unsupervise",
"removes",
"the",
"mapping",
"from",
"cache",
"and",
"cleans",
"up",
"the",
"iptable",
"rules",
".",
"ALL",
"remove",
"operations",
"will",
"print",
"errors",
"by",
"they",
"don",
"t",
"return",
"error",
".",
"We",
"want",
"to",
"force",
"as... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L133-L159 |
6,918 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | CleanUp | func (s *Config) CleanUp() error {
s.Lock()
defer s.Unlock()
return s.impl.CleanUp()
} | go | func (s *Config) CleanUp() error {
s.Lock()
defer s.Unlock()
return s.impl.CleanUp()
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"CleanUp",
"(",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"impl",
".",
"CleanUp",
"(",
")",
"\n",
"}"
] | // CleanUp implements the cleanup interface | [
"CleanUp",
"implements",
"the",
"cleanup",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L162-L167 |
6,919 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | SetTargetNetworks | func (s *Config) SetTargetNetworks(cfg *runtime.Configuration) error {
s.Lock()
defer s.Unlock()
return s.impl.SetTargetNetworks(cfg)
} | go | func (s *Config) SetTargetNetworks(cfg *runtime.Configuration) error {
s.Lock()
defer s.Unlock()
return s.impl.SetTargetNetworks(cfg)
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"SetTargetNetworks",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"impl",
".",
"SetTa... | // SetTargetNetworks sets the target networks of the supervisor | [
"SetTargetNetworks",
"sets",
"the",
"target",
"networks",
"of",
"the",
"supervisor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L170-L176 |
6,920 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | doUpdatePU | func (s *Config) doUpdatePU(contextID string, pu *policy.PUInfo) error {
s.Lock()
data, err := s.versionTracker.LockedModify(contextID, revert, 1)
if err != nil {
return fmt.Errorf("unable to find pu %s in cache: %s", contextID, err)
}
c := data.(*cacheData)
if err := s.impl.UpdateRules(c.version, contextID, pu, c.containerInfo); err != nil {
// Try to clean up, even though this is fatal and it will most likely fail
s.Unlock()
s.Unsupervise(contextID) // nolint
return err
}
// Updated the policy in the cached processing unit.
c.containerInfo.Policy = pu.Policy
s.Unlock()
return nil
} | go | func (s *Config) doUpdatePU(contextID string, pu *policy.PUInfo) error {
s.Lock()
data, err := s.versionTracker.LockedModify(contextID, revert, 1)
if err != nil {
return fmt.Errorf("unable to find pu %s in cache: %s", contextID, err)
}
c := data.(*cacheData)
if err := s.impl.UpdateRules(c.version, contextID, pu, c.containerInfo); err != nil {
// Try to clean up, even though this is fatal and it will most likely fail
s.Unlock()
s.Unsupervise(contextID) // nolint
return err
}
// Updated the policy in the cached processing unit.
c.containerInfo.Policy = pu.Policy
s.Unlock()
return nil
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"doUpdatePU",
"(",
"contextID",
"string",
",",
"pu",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n\n",
"data",
",",
"err",
":=",
"s",
".",
"versionTracker",
".",
"LockedModify",... | // UpdatePU creates a mapping between an IP address and the corresponding labels
//and the invokes the various handlers that process all policies. | [
"UpdatePU",
"creates",
"a",
"mapping",
"between",
"an",
"IP",
"address",
"and",
"the",
"corresponding",
"labels",
"and",
"the",
"invokes",
"the",
"various",
"handlers",
"that",
"process",
"all",
"policies",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L217-L239 |
6,921 | aporeto-inc/trireme-lib | controller/internal/supervisor/supervisor.go | EnableIPTablesPacketTracing | func (s *Config) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
data, err := s.versionTracker.Get(contextID)
if err != nil {
return fmt.Errorf("cannot find policy version: %s", err)
}
cfg := data.(*cacheData)
iptablesRules := debugRules(cfg, s.mode)
ipt := s.impl.ACLProvider()
for _, rule := range iptablesRules {
if err := ipt.Insert(rule[0], rule[1], 1, rule[2:]...); err != nil {
zap.L().Error("Unable to install rule", zap.Error(err))
}
}
// anonymous go func to flush debug iptables after interval
go func() {
for {
select {
case <-ctx.Done():
case <-time.After(interval):
for _, rule := range iptablesRules {
if err := ipt.Delete(rule[0], rule[1], rule[2:]...); err != nil {
zap.L().Debug("Unable to delete trace rules", zap.Error(err))
}
}
}
}
}()
return nil
} | go | func (s *Config) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
data, err := s.versionTracker.Get(contextID)
if err != nil {
return fmt.Errorf("cannot find policy version: %s", err)
}
cfg := data.(*cacheData)
iptablesRules := debugRules(cfg, s.mode)
ipt := s.impl.ACLProvider()
for _, rule := range iptablesRules {
if err := ipt.Insert(rule[0], rule[1], 1, rule[2:]...); err != nil {
zap.L().Error("Unable to install rule", zap.Error(err))
}
}
// anonymous go func to flush debug iptables after interval
go func() {
for {
select {
case <-ctx.Done():
case <-time.After(interval):
for _, rule := range iptablesRules {
if err := ipt.Delete(rule[0], rule[1], rule[2:]...); err != nil {
zap.L().Debug("Unable to delete trace rules", zap.Error(err))
}
}
}
}
}()
return nil
} | [
"func",
"(",
"s",
"*",
"Config",
")",
"EnableIPTablesPacketTracing",
"(",
"ctx",
"context",
".",
"Context",
",",
"contextID",
"string",
",",
"interval",
"time",
".",
"Duration",
")",
"error",
"{",
"data",
",",
"err",
":=",
"s",
".",
"versionTracker",
".",
... | // EnableIPTablesPacketTracing enables ip tables packet tracing | [
"EnableIPTablesPacketTracing",
"enables",
"ip",
"tables",
"packet",
"tracing"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/supervisor.go#L242-L274 |
6,922 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | New | func New(serverID string, validity time.Duration, secret secrets.Secrets) (TokenAccessor, error) {
tokenEngine, err := tokens.NewJWT(validity, serverID, secret)
if err != nil {
return nil, err
}
return &tokenAccessor{
tokens: tokenEngine,
serverID: serverID,
validity: validity,
}, nil
} | go | func New(serverID string, validity time.Duration, secret secrets.Secrets) (TokenAccessor, error) {
tokenEngine, err := tokens.NewJWT(validity, serverID, secret)
if err != nil {
return nil, err
}
return &tokenAccessor{
tokens: tokenEngine,
serverID: serverID,
validity: validity,
}, nil
} | [
"func",
"New",
"(",
"serverID",
"string",
",",
"validity",
"time",
".",
"Duration",
",",
"secret",
"secrets",
".",
"Secrets",
")",
"(",
"TokenAccessor",
",",
"error",
")",
"{",
"tokenEngine",
",",
"err",
":=",
"tokens",
".",
"NewJWT",
"(",
"validity",
",... | // New creates a new instance of TokenAccessor interface | [
"New",
"creates",
"a",
"new",
"instance",
"of",
"TokenAccessor",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L26-L38 |
6,923 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | SetToken | func (t *tokenAccessor) SetToken(serverID string, validity time.Duration, secret secrets.Secrets) error {
t.Lock()
defer t.Unlock()
tokenEngine, err := tokens.NewJWT(validity, serverID, secret)
if err != nil {
return err
}
t.tokens = tokenEngine
return nil
} | go | func (t *tokenAccessor) SetToken(serverID string, validity time.Duration, secret secrets.Secrets) error {
t.Lock()
defer t.Unlock()
tokenEngine, err := tokens.NewJWT(validity, serverID, secret)
if err != nil {
return err
}
t.tokens = tokenEngine
return nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"SetToken",
"(",
"serverID",
"string",
",",
"validity",
"time",
".",
"Duration",
",",
"secret",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
... | // SetToken updates sthe stored token in the struct | [
"SetToken",
"updates",
"sthe",
"stored",
"token",
"in",
"the",
"struct"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L49-L59 |
6,924 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | CreateAckPacketToken | func (t *tokenAccessor) CreateAckPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo) ([]byte, error) {
claims := &tokens.ConnectionClaims{
LCL: auth.LocalContext,
RMT: auth.RemoteContext,
}
token, err := t.getToken().CreateAndSign(true, claims, auth.LocalContext, claimsheader.NewClaimsHeader())
if err != nil {
return []byte{}, err
}
return token, nil
} | go | func (t *tokenAccessor) CreateAckPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo) ([]byte, error) {
claims := &tokens.ConnectionClaims{
LCL: auth.LocalContext,
RMT: auth.RemoteContext,
}
token, err := t.getToken().CreateAndSign(true, claims, auth.LocalContext, claimsheader.NewClaimsHeader())
if err != nil {
return []byte{}, err
}
return token, nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"CreateAckPacketToken",
"(",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"auth",
"*",
"connection",
".",
"AuthInfo",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"claims",
":=",
"&",
"tokens",
... | // CreateAckPacketToken creates the authentication token | [
"CreateAckPacketToken",
"creates",
"the",
"authentication",
"token"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L72-L85 |
6,925 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | CreateSynPacketToken | func (t *tokenAccessor) CreateSynPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo) (token []byte, err error) {
token, serviceContext, err := context.GetCachedTokenAndServiceContext()
if err == nil && bytes.Equal(auth.LocalServiceContext, serviceContext) {
// Randomize the nonce and send it
err = t.getToken().Randomize(token, auth.LocalContext)
if err == nil {
return token, nil
}
// If there is an error, let's try to create a new one
}
claims := &tokens.ConnectionClaims{
T: context.Identity(),
EK: auth.LocalServiceContext,
}
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsheader.NewClaimsHeader()); err != nil {
return []byte{}, nil
}
context.UpdateCachedTokenAndServiceContext(token, auth.LocalServiceContext)
return token, nil
} | go | func (t *tokenAccessor) CreateSynPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo) (token []byte, err error) {
token, serviceContext, err := context.GetCachedTokenAndServiceContext()
if err == nil && bytes.Equal(auth.LocalServiceContext, serviceContext) {
// Randomize the nonce and send it
err = t.getToken().Randomize(token, auth.LocalContext)
if err == nil {
return token, nil
}
// If there is an error, let's try to create a new one
}
claims := &tokens.ConnectionClaims{
T: context.Identity(),
EK: auth.LocalServiceContext,
}
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsheader.NewClaimsHeader()); err != nil {
return []byte{}, nil
}
context.UpdateCachedTokenAndServiceContext(token, auth.LocalServiceContext)
return token, nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"CreateSynPacketToken",
"(",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"auth",
"*",
"connection",
".",
"AuthInfo",
")",
"(",
"token",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"token",
",",
... | // createSynPacketToken creates the authentication token | [
"createSynPacketToken",
"creates",
"the",
"authentication",
"token"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L88-L112 |
6,926 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | CreateSynAckPacketToken | func (t *tokenAccessor) CreateSynAckPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo, claimsHeader *claimsheader.ClaimsHeader) (token []byte, err error) {
claims := &tokens.ConnectionClaims{
T: context.Identity(),
RMT: auth.RemoteContext,
EK: auth.LocalServiceContext,
}
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsHeader); err != nil {
return []byte{}, nil
}
return token, nil
} | go | func (t *tokenAccessor) CreateSynAckPacketToken(context *pucontext.PUContext, auth *connection.AuthInfo, claimsHeader *claimsheader.ClaimsHeader) (token []byte, err error) {
claims := &tokens.ConnectionClaims{
T: context.Identity(),
RMT: auth.RemoteContext,
EK: auth.LocalServiceContext,
}
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsHeader); err != nil {
return []byte{}, nil
}
return token, nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"CreateSynAckPacketToken",
"(",
"context",
"*",
"pucontext",
".",
"PUContext",
",",
"auth",
"*",
"connection",
".",
"AuthInfo",
",",
"claimsHeader",
"*",
"claimsheader",
".",
"ClaimsHeader",
")",
"(",
"token",
"[",
... | // createSynAckPacketToken creates the authentication token for SynAck packets
// We need to sign the received token. No caching possible here | [
"createSynAckPacketToken",
"creates",
"the",
"authentication",
"token",
"for",
"SynAck",
"packets",
"We",
"need",
"to",
"sign",
"the",
"received",
"token",
".",
"No",
"caching",
"possible",
"here"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L116-L129 |
6,927 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | ParsePacketToken | func (t *tokenAccessor) ParsePacketToken(auth *connection.AuthInfo, data []byte) (*tokens.ConnectionClaims, error) {
// Validate the certificate and parse the token
claims, nonce, cert, err := t.getToken().Decode(false, data, auth.RemotePublicKey)
if err != nil {
return nil, err
}
// We always a need a valid remote context ID
if claims.T == nil {
return nil, errors.New("no claims found")
}
remoteContextID, ok := claims.T.Get(enforcerconstants.TransmitterLabel)
if !ok {
return nil, errors.New("no transmitter label")
}
auth.RemotePublicKey = cert
auth.RemoteContext = nonce
auth.RemoteContextID = remoteContextID
auth.RemoteServiceContext = claims.EK
return claims, nil
} | go | func (t *tokenAccessor) ParsePacketToken(auth *connection.AuthInfo, data []byte) (*tokens.ConnectionClaims, error) {
// Validate the certificate and parse the token
claims, nonce, cert, err := t.getToken().Decode(false, data, auth.RemotePublicKey)
if err != nil {
return nil, err
}
// We always a need a valid remote context ID
if claims.T == nil {
return nil, errors.New("no claims found")
}
remoteContextID, ok := claims.T.Get(enforcerconstants.TransmitterLabel)
if !ok {
return nil, errors.New("no transmitter label")
}
auth.RemotePublicKey = cert
auth.RemoteContext = nonce
auth.RemoteContextID = remoteContextID
auth.RemoteServiceContext = claims.EK
return claims, nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"ParsePacketToken",
"(",
"auth",
"*",
"connection",
".",
"AuthInfo",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"tokens",
".",
"ConnectionClaims",
",",
"error",
")",
"{",
"// Validate the certificate and parse th... | // parsePacketToken parses the packet token and populates the right state.
// Returns an error if the token cannot be parsed or the signature fails | [
"parsePacketToken",
"parses",
"the",
"packet",
"token",
"and",
"populates",
"the",
"right",
"state",
".",
"Returns",
"an",
"error",
"if",
"the",
"token",
"cannot",
"be",
"parsed",
"or",
"the",
"signature",
"fails"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L133-L156 |
6,928 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go | ParseAckToken | func (t *tokenAccessor) ParseAckToken(auth *connection.AuthInfo, data []byte) (*tokens.ConnectionClaims, error) {
gt := t.getToken()
if gt == nil {
return nil, errors.New("token is nil")
}
if auth == nil {
return nil, errors.New("auth is nil")
}
// Validate the certificate and parse the token
claims, _, _, err := t.getToken().Decode(true, data, auth.RemotePublicKey)
if err != nil {
return nil, err
}
// Compare the incoming random context with the stored context
matchLocal := bytes.Compare(claims.RMT, auth.LocalContext)
matchRemote := bytes.Compare(claims.LCL, auth.RemoteContext)
if matchLocal != 0 || matchRemote != 0 {
return nil, errors.New("failed to match context in ack packet")
}
return claims, nil
} | go | func (t *tokenAccessor) ParseAckToken(auth *connection.AuthInfo, data []byte) (*tokens.ConnectionClaims, error) {
gt := t.getToken()
if gt == nil {
return nil, errors.New("token is nil")
}
if auth == nil {
return nil, errors.New("auth is nil")
}
// Validate the certificate and parse the token
claims, _, _, err := t.getToken().Decode(true, data, auth.RemotePublicKey)
if err != nil {
return nil, err
}
// Compare the incoming random context with the stored context
matchLocal := bytes.Compare(claims.RMT, auth.LocalContext)
matchRemote := bytes.Compare(claims.LCL, auth.RemoteContext)
if matchLocal != 0 || matchRemote != 0 {
return nil, errors.New("failed to match context in ack packet")
}
return claims, nil
} | [
"func",
"(",
"t",
"*",
"tokenAccessor",
")",
"ParseAckToken",
"(",
"auth",
"*",
"connection",
".",
"AuthInfo",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"tokens",
".",
"ConnectionClaims",
",",
"error",
")",
"{",
"gt",
":=",
"t",
".",
"getToken",
... | // parseAckToken parses the tokens in Ack packets. They don't carry all the state context
// and it needs to be recovered | [
"parseAckToken",
"parses",
"the",
"tokens",
"in",
"Ack",
"packets",
".",
"They",
"don",
"t",
"carry",
"all",
"the",
"state",
"context",
"and",
"it",
"needs",
"to",
"be",
"recovered"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/tokenaccessor/tokenaccessor.go#L160-L183 |
6,929 | aporeto-inc/trireme-lib | collector/mockcollector/mockcollector.go | NewMockEventCollector | func NewMockEventCollector(ctrl *gomock.Controller) *MockEventCollector {
mock := &MockEventCollector{ctrl: ctrl}
mock.recorder = &MockEventCollectorMockRecorder{mock}
return mock
} | go | func NewMockEventCollector(ctrl *gomock.Controller) *MockEventCollector {
mock := &MockEventCollector{ctrl: ctrl}
mock.recorder = &MockEventCollectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockEventCollector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEventCollector",
"{",
"mock",
":=",
"&",
"MockEventCollector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEventCollectorMockRecorder"... | // NewMockEventCollector creates a new mock instance
// nolint | [
"NewMockEventCollector",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/collector/mockcollector/mockcollector.go#L29-L33 |
6,930 | aporeto-inc/trireme-lib | collector/mockcollector/mockcollector.go | CollectFlowEvent | func (mr *MockEventCollectorMockRecorder) CollectFlowEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectFlowEvent", reflect.TypeOf((*MockEventCollector)(nil).CollectFlowEvent), record)
} | go | func (mr *MockEventCollectorMockRecorder) CollectFlowEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectFlowEvent", reflect.TypeOf((*MockEventCollector)(nil).CollectFlowEvent), record)
} | [
"func",
"(",
"mr",
"*",
"MockEventCollectorMockRecorder",
")",
"CollectFlowEvent",
"(",
"record",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
... | // CollectFlowEvent indicates an expected call of CollectFlowEvent
// nolint | [
"CollectFlowEvent",
"indicates",
"an",
"expected",
"call",
"of",
"CollectFlowEvent",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/collector/mockcollector/mockcollector.go#L49-L51 |
6,931 | aporeto-inc/trireme-lib | controller/pkg/usertokens/oidc/oidc.go | NewClient | func NewClient(ctx context.Context, v *TokenVerifier) (*TokenVerifier, error) {
// Initialize caches only once if they are nil.
if stateCache == nil {
stateCache = gcache.New(2048).LRU().Expiration(120 * time.Second).Build()
}
if tokenCache == nil {
tokenCache = gcache.New(2048).LRU().Build()
}
// Create a new generic OIDC provider based on the provider URL.
// The library will auto-discover the configuration of the provider.
// If it is not a compliant provider we should report and error here.
provider, err := oidc.NewProvider(ctx, v.ProviderURL)
if err != nil {
return nil, fmt.Errorf("Failed to initialize provider: %s", err)
}
oidConfig := &oidc.Config{
ClientID: v.ClientID,
SkipClientIDCheck: true,
}
v.oauthVerifier = provider.Verifier(oidConfig)
scopes := []string{oidc.ScopeOpenID, "profile", "email"}
for _, scope := range v.Scopes {
if scope != oidc.ScopeOpenID && scope != "profile" && scope != "email" {
scopes = append(scopes, scope)
}
}
v.clientConfig = &oauth2.Config{
ClientID: v.ClientID,
ClientSecret: v.ClientSecret,
Endpoint: provider.Endpoint(),
RedirectURL: v.RedirectURL,
Scopes: scopes,
}
// Google does not honor the OIDC standard to refresh tokens
// with a proper scope. Instead it requires a prompt parameter
// to be passed. In order to deal wit this, we will have to
// detect Google as the OIDC and pass the parameters.
if strings.Contains(v.ProviderURL, "accounts.google.com") {
v.googleHack = true
}
return v, nil
} | go | func NewClient(ctx context.Context, v *TokenVerifier) (*TokenVerifier, error) {
// Initialize caches only once if they are nil.
if stateCache == nil {
stateCache = gcache.New(2048).LRU().Expiration(120 * time.Second).Build()
}
if tokenCache == nil {
tokenCache = gcache.New(2048).LRU().Build()
}
// Create a new generic OIDC provider based on the provider URL.
// The library will auto-discover the configuration of the provider.
// If it is not a compliant provider we should report and error here.
provider, err := oidc.NewProvider(ctx, v.ProviderURL)
if err != nil {
return nil, fmt.Errorf("Failed to initialize provider: %s", err)
}
oidConfig := &oidc.Config{
ClientID: v.ClientID,
SkipClientIDCheck: true,
}
v.oauthVerifier = provider.Verifier(oidConfig)
scopes := []string{oidc.ScopeOpenID, "profile", "email"}
for _, scope := range v.Scopes {
if scope != oidc.ScopeOpenID && scope != "profile" && scope != "email" {
scopes = append(scopes, scope)
}
}
v.clientConfig = &oauth2.Config{
ClientID: v.ClientID,
ClientSecret: v.ClientSecret,
Endpoint: provider.Endpoint(),
RedirectURL: v.RedirectURL,
Scopes: scopes,
}
// Google does not honor the OIDC standard to refresh tokens
// with a proper scope. Instead it requires a prompt parameter
// to be passed. In order to deal wit this, we will have to
// detect Google as the OIDC and pass the parameters.
if strings.Contains(v.ProviderURL, "accounts.google.com") {
v.googleHack = true
}
return v, nil
} | [
"func",
"NewClient",
"(",
"ctx",
"context",
".",
"Context",
",",
"v",
"*",
"TokenVerifier",
")",
"(",
"*",
"TokenVerifier",
",",
"error",
")",
"{",
"// Initialize caches only once if they are nil.",
"if",
"stateCache",
"==",
"nil",
"{",
"stateCache",
"=",
"gcach... | // NewClient creates a new validator client | [
"NewClient",
"creates",
"a",
"new",
"validator",
"client"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/usertokens/oidc/oidc.go#L56-L102 |
6,932 | aporeto-inc/trireme-lib | controller/pkg/usertokens/oidc/oidc.go | Callback | func (v *TokenVerifier) Callback(r *http.Request) (string, string, int, error) {
// We first validate that the callback state matches the original redirect
// state. We clean up the cache once it is validated. During this process
// we recover the original URL that initiated the protocol. This allows
// us to redirect the client to their original request.
receivedState := r.URL.Query().Get("state")
originURL, err := stateCache.Get(receivedState)
if err != nil {
return "", "", http.StatusBadRequest, fmt.Errorf("bad state")
}
stateCache.Remove(receivedState)
// We exchange the authorization code with an OAUTH token. This is the main
// step where the OAUTH provider will match the code to the token.
oauth2Token, err := v.clientConfig.Exchange(r.Context(), r.URL.Query().Get("code"), oauth2.AccessTypeOffline)
if err != nil {
return "", "", http.StatusInternalServerError, fmt.Errorf("bad code: %s", err)
}
// We extract the rawID token.
rawIDToken, ok := oauth2Token.Extra("id_token").(string)
if !ok {
return "", "", http.StatusInternalServerError, fmt.Errorf("bad ID")
}
if err := tokenCache.SetWithExpire(
rawIDToken,
&clientData{
tokenSource: v.clientConfig.TokenSource(context.Background(), oauth2Token),
expiry: oauth2Token.Expiry,
},
time.Until(oauth2Token.Expiry.Add(3600*time.Second)),
); err != nil {
return "", "", http.StatusInternalServerError, fmt.Errorf("failed to insert token in the cache: %s", err)
}
return rawIDToken, originURL.(string), http.StatusTemporaryRedirect, nil
} | go | func (v *TokenVerifier) Callback(r *http.Request) (string, string, int, error) {
// We first validate that the callback state matches the original redirect
// state. We clean up the cache once it is validated. During this process
// we recover the original URL that initiated the protocol. This allows
// us to redirect the client to their original request.
receivedState := r.URL.Query().Get("state")
originURL, err := stateCache.Get(receivedState)
if err != nil {
return "", "", http.StatusBadRequest, fmt.Errorf("bad state")
}
stateCache.Remove(receivedState)
// We exchange the authorization code with an OAUTH token. This is the main
// step where the OAUTH provider will match the code to the token.
oauth2Token, err := v.clientConfig.Exchange(r.Context(), r.URL.Query().Get("code"), oauth2.AccessTypeOffline)
if err != nil {
return "", "", http.StatusInternalServerError, fmt.Errorf("bad code: %s", err)
}
// We extract the rawID token.
rawIDToken, ok := oauth2Token.Extra("id_token").(string)
if !ok {
return "", "", http.StatusInternalServerError, fmt.Errorf("bad ID")
}
if err := tokenCache.SetWithExpire(
rawIDToken,
&clientData{
tokenSource: v.clientConfig.TokenSource(context.Background(), oauth2Token),
expiry: oauth2Token.Expiry,
},
time.Until(oauth2Token.Expiry.Add(3600*time.Second)),
); err != nil {
return "", "", http.StatusInternalServerError, fmt.Errorf("failed to insert token in the cache: %s", err)
}
return rawIDToken, originURL.(string), http.StatusTemporaryRedirect, nil
} | [
"func",
"(",
"v",
"*",
"TokenVerifier",
")",
"Callback",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"string",
",",
"int",
",",
"error",
")",
"{",
"// We first validate that the callback state matches the original redirect",
"// state. We clean u... | // Callback is the function that is called back by the IDP to catch the token
// and perform all other validations. It will return the resulting token,
// the original URL that was called to initiate the protocol, and the
// http status response. | [
"Callback",
"is",
"the",
"function",
"that",
"is",
"called",
"back",
"by",
"the",
"IDP",
"to",
"catch",
"the",
"token",
"and",
"perform",
"all",
"other",
"validations",
".",
"It",
"will",
"return",
"the",
"resulting",
"token",
"the",
"original",
"URL",
"th... | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/usertokens/oidc/oidc.go#L132-L170 |
6,933 | aporeto-inc/trireme-lib | controller/internal/enforcer/acls/aclcache.go | AddRule | func (c *ACLCache) AddRule(rule policy.IPRule) (err error) {
if rule.Policy.ObserveAction.ObserveApply() {
return c.observe.addRule(rule)
}
if rule.Policy.Action.Accepted() {
return c.accept.addRule(rule)
}
return c.reject.addRule(rule)
} | go | func (c *ACLCache) AddRule(rule policy.IPRule) (err error) {
if rule.Policy.ObserveAction.ObserveApply() {
return c.observe.addRule(rule)
}
if rule.Policy.Action.Accepted() {
return c.accept.addRule(rule)
}
return c.reject.addRule(rule)
} | [
"func",
"(",
"c",
"*",
"ACLCache",
")",
"AddRule",
"(",
"rule",
"policy",
".",
"IPRule",
")",
"(",
"err",
"error",
")",
"{",
"if",
"rule",
".",
"Policy",
".",
"ObserveAction",
".",
"ObserveApply",
"(",
")",
"{",
"return",
"c",
".",
"observe",
".",
... | // AddRule adds a single rule to the ACL Cache | [
"AddRule",
"adds",
"a",
"single",
"rule",
"to",
"the",
"ACL",
"Cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/acls/aclcache.go#L34-L45 |
6,934 | aporeto-inc/trireme-lib | controller/internal/enforcer/acls/aclcache.go | AddRuleList | func (c *ACLCache) AddRuleList(rules policy.IPRuleList) (err error) {
for _, rule := range rules {
if err = c.AddRule(rule); err != nil {
return
}
}
c.reject.reverseSort()
c.accept.reverseSort()
c.observe.reverseSort()
return
} | go | func (c *ACLCache) AddRuleList(rules policy.IPRuleList) (err error) {
for _, rule := range rules {
if err = c.AddRule(rule); err != nil {
return
}
}
c.reject.reverseSort()
c.accept.reverseSort()
c.observe.reverseSort()
return
} | [
"func",
"(",
"c",
"*",
"ACLCache",
")",
"AddRuleList",
"(",
"rules",
"policy",
".",
"IPRuleList",
")",
"(",
"err",
"error",
")",
"{",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"if",
"err",
"=",
"c",
".",
"AddRule",
"(",
"rule",
")",
"... | // AddRuleList adds a list of rules to the cache | [
"AddRuleList",
"adds",
"a",
"list",
"of",
"rules",
"to",
"the",
"cache"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/acls/aclcache.go#L48-L60 |
6,935 | aporeto-inc/trireme-lib | controller/internal/enforcer/acls/aclcache.go | GetMatchingAction | func (c *ACLCache) GetMatchingAction(ip []byte, port uint16) (report *policy.FlowPolicy, packet *policy.FlowPolicy, err error) {
report, packet, err = c.reject.getMatchingAction(ip, port, report)
if err == nil {
return
}
report, packet, err = c.accept.getMatchingAction(ip, port, report)
if err == nil {
return
}
report, packet, err = c.observe.getMatchingAction(ip, port, report)
if err == nil {
return
}
if report == nil {
report = catchAllPolicy
}
if packet == nil {
packet = catchAllPolicy
}
return report, packet, errors.New("no match")
} | go | func (c *ACLCache) GetMatchingAction(ip []byte, port uint16) (report *policy.FlowPolicy, packet *policy.FlowPolicy, err error) {
report, packet, err = c.reject.getMatchingAction(ip, port, report)
if err == nil {
return
}
report, packet, err = c.accept.getMatchingAction(ip, port, report)
if err == nil {
return
}
report, packet, err = c.observe.getMatchingAction(ip, port, report)
if err == nil {
return
}
if report == nil {
report = catchAllPolicy
}
if packet == nil {
packet = catchAllPolicy
}
return report, packet, errors.New("no match")
} | [
"func",
"(",
"c",
"*",
"ACLCache",
")",
"GetMatchingAction",
"(",
"ip",
"[",
"]",
"byte",
",",
"port",
"uint16",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"packet",
"*",
"policy",
".",
"FlowPolicy",
",",
"err",
"error",
")",
"{",
"re... | // GetMatchingAction gets the matching action | [
"GetMatchingAction",
"gets",
"the",
"matching",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/acls/aclcache.go#L63-L89 |
6,936 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | Enforce | func (s *ProxyInfo) Enforce(contextID string, puInfo *policy.PUInfo) error {
initEnforcer, err := s.prochdl.LaunchRemoteEnforcer(
contextID,
puInfo.Runtime.Pid(),
puInfo.Runtime.NSPath(),
s.commandArg,
s.statsServerSecret,
s.procMountPoint,
)
if err != nil {
return err
}
zap.L().Debug("Called enforce and launched process", zap.String("contextID", contextID),
zap.Reflect("Policy Object", puInfo))
if initEnforcer {
if err := s.initRemoteEnforcer(contextID); err != nil {
s.prochdl.KillRemoteEnforcer(contextID, true) // nolint errcheck
return err
}
}
enforcerPayload := &rpcwrapper.EnforcePayload{
ContextID: contextID,
Policy: puInfo.Policy.ToPublicPolicy(),
}
//Only the secrets need to be under lock. They can change async to the enforce call from Updatesecrets
s.RLock()
enforcerPayload.Secrets = s.Secrets.PublicSecrets()
s.RUnlock()
request := &rpcwrapper.Request{
Payload: enforcerPayload,
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.Enforce, request, &rpcwrapper.Response{}); err != nil {
s.prochdl.KillRemoteEnforcer(contextID, true) // nolint errcheck
return fmt.Errorf("failed to send message to remote enforcer: %s", err)
}
return nil
} | go | func (s *ProxyInfo) Enforce(contextID string, puInfo *policy.PUInfo) error {
initEnforcer, err := s.prochdl.LaunchRemoteEnforcer(
contextID,
puInfo.Runtime.Pid(),
puInfo.Runtime.NSPath(),
s.commandArg,
s.statsServerSecret,
s.procMountPoint,
)
if err != nil {
return err
}
zap.L().Debug("Called enforce and launched process", zap.String("contextID", contextID),
zap.Reflect("Policy Object", puInfo))
if initEnforcer {
if err := s.initRemoteEnforcer(contextID); err != nil {
s.prochdl.KillRemoteEnforcer(contextID, true) // nolint errcheck
return err
}
}
enforcerPayload := &rpcwrapper.EnforcePayload{
ContextID: contextID,
Policy: puInfo.Policy.ToPublicPolicy(),
}
//Only the secrets need to be under lock. They can change async to the enforce call from Updatesecrets
s.RLock()
enforcerPayload.Secrets = s.Secrets.PublicSecrets()
s.RUnlock()
request := &rpcwrapper.Request{
Payload: enforcerPayload,
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.Enforce, request, &rpcwrapper.Response{}); err != nil {
s.prochdl.KillRemoteEnforcer(contextID, true) // nolint errcheck
return fmt.Errorf("failed to send message to remote enforcer: %s", err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"Enforce",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"initEnforcer",
",",
"err",
":=",
"s",
".",
"prochdl",
".",
"LaunchRemoteEnforcer",
"(",
"contextID",
",",
"pu... | // Enforce method makes a RPC call for the remote enforcer enforce method | [
"Enforce",
"method",
"makes",
"a",
"RPC",
"call",
"for",
"the",
"remote",
"enforcer",
"enforce",
"method"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L50-L93 |
6,937 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | Unenforce | func (s *ProxyInfo) Unenforce(contextID string) error {
request := &rpcwrapper.Request{
Payload: &rpcwrapper.UnEnforcePayload{
ContextID: contextID,
},
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.Unenforce, request, &rpcwrapper.Response{}); err != nil {
zap.L().Error("failed to send message to remote enforcer", zap.Error(err))
}
return s.prochdl.KillRemoteEnforcer(contextID, true)
} | go | func (s *ProxyInfo) Unenforce(contextID string) error {
request := &rpcwrapper.Request{
Payload: &rpcwrapper.UnEnforcePayload{
ContextID: contextID,
},
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.Unenforce, request, &rpcwrapper.Response{}); err != nil {
zap.L().Error("failed to send message to remote enforcer", zap.Error(err))
}
return s.prochdl.KillRemoteEnforcer(contextID, true)
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"Unenforce",
"(",
"contextID",
"string",
")",
"error",
"{",
"request",
":=",
"&",
"rpcwrapper",
".",
"Request",
"{",
"Payload",
":",
"&",
"rpcwrapper",
".",
"UnEnforcePayload",
"{",
"ContextID",
":",
"contextID",
",... | // Unenforce stops enforcing policy for the given contextID. | [
"Unenforce",
"stops",
"enforcing",
"policy",
"for",
"the",
"given",
"contextID",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L96-L109 |
6,938 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | CleanUp | func (s *ProxyInfo) CleanUp() error {
// request := &rpcwrapper.Request{}
var allErrors string
for _, contextID := range s.rpchdl.ContextList() {
if err := s.prochdl.KillRemoteEnforcer(contextID, false); err != nil {
allErrors = allErrors + " contextID:" + err.Error()
}
}
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | go | func (s *ProxyInfo) CleanUp() error {
// request := &rpcwrapper.Request{}
var allErrors string
for _, contextID := range s.rpchdl.ContextList() {
if err := s.prochdl.KillRemoteEnforcer(contextID, false); err != nil {
allErrors = allErrors + " contextID:" + err.Error()
}
}
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"CleanUp",
"(",
")",
"error",
"{",
"// request := &rpcwrapper.Request{}",
"var",
"allErrors",
"string",
"\n\n",
"for",
"_",
",",
"contextID",
":=",
"range",
"s",
".",
"rpchdl",
".",
"ContextList",
"(",
")",
"{",
"if... | // CleanUp sends a cleanup command to all the remotes forcing them to exit and clean their state. | [
"CleanUp",
"sends",
"a",
"cleanup",
"command",
"to",
"all",
"the",
"remotes",
"forcing",
"them",
"to",
"exit",
"and",
"clean",
"their",
"state",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L140-L158 |
6,939 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | EnableDatapathPacketTracing | func (s *ProxyInfo) EnableDatapathPacketTracing(contextID string, direction packettracing.TracingDirection, interval time.Duration) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.EnableDatapathPacketTracingPayLoad{
Direction: direction,
Interval: interval,
ContextID: contextID,
},
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.EnableDatapathPacketTracing, request, resp); err != nil {
return fmt.Errorf("unable to enable datapath packet tracing %s -- %s", err, resp.Status)
}
return nil
} | go | func (s *ProxyInfo) EnableDatapathPacketTracing(contextID string, direction packettracing.TracingDirection, interval time.Duration) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.EnableDatapathPacketTracingPayLoad{
Direction: direction,
Interval: interval,
ContextID: contextID,
},
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.EnableDatapathPacketTracing, request, resp); err != nil {
return fmt.Errorf("unable to enable datapath packet tracing %s -- %s", err, resp.Status)
}
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"EnableDatapathPacketTracing",
"(",
"contextID",
"string",
",",
"direction",
"packettracing",
".",
"TracingDirection",
",",
"interval",
"time",
".",
"Duration",
")",
"error",
"{",
"resp",
":=",
"&",
"rpcwrapper",
".",
"... | // EnableDatapathPacketTracing enable nfq packet tracing in remote container | [
"EnableDatapathPacketTracing",
"enable",
"nfq",
"packet",
"tracing",
"in",
"remote",
"container"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L161-L178 |
6,940 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | SetTargetNetworks | func (s *ProxyInfo) SetTargetNetworks(cfg *runtime.Configuration) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.SetTargetNetworksPayload{
Configuration: cfg,
},
}
var allErrors string
for _, contextID := range s.rpchdl.ContextList() {
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.SetTargetNetworks, request, resp); err != nil {
allErrors = allErrors + " contextID " + contextID + ":" + err.Error()
}
}
s.Lock()
s.cfg = cfg
s.Unlock()
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | go | func (s *ProxyInfo) SetTargetNetworks(cfg *runtime.Configuration) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.SetTargetNetworksPayload{
Configuration: cfg,
},
}
var allErrors string
for _, contextID := range s.rpchdl.ContextList() {
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.SetTargetNetworks, request, resp); err != nil {
allErrors = allErrors + " contextID " + contextID + ":" + err.Error()
}
}
s.Lock()
s.cfg = cfg
s.Unlock()
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"SetTargetNetworks",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"resp",
":=",
"&",
"rpcwrapper",
".",
"Response",
"{",
"}",
"\n",
"request",
":=",
"&",
"rpcwrapper",
".",
"Request",
"{",
... | // SetTargetNetworks does the RPC call for SetTargetNetworks to the corresponding
// remote enforcers | [
"SetTargetNetworks",
"does",
"the",
"RPC",
"call",
"for",
"SetTargetNetworks",
"to",
"the",
"corresponding",
"remote",
"enforcers"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L200-L225 |
6,941 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | Run | func (s *ProxyInfo) Run(ctx context.Context) error {
statsServer := rpcwrapper.NewRPCWrapper()
rpcServer := &StatsServer{
rpchdl: statsServer,
collector: s.collector,
secret: s.statsServerSecret,
}
// Start the server for statistics collection.
go statsServer.StartServer(ctx, "unix", constants.StatsChannel, rpcServer) // nolint
return nil
} | go | func (s *ProxyInfo) Run(ctx context.Context) error {
statsServer := rpcwrapper.NewRPCWrapper()
rpcServer := &StatsServer{
rpchdl: statsServer,
collector: s.collector,
secret: s.statsServerSecret,
}
// Start the server for statistics collection.
go statsServer.StartServer(ctx, "unix", constants.StatsChannel, rpcServer) // nolint
return nil
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"statsServer",
":=",
"rpcwrapper",
".",
"NewRPCWrapper",
"(",
")",
"\n",
"rpcServer",
":=",
"&",
"StatsServer",
"{",
"rpchdl",
":",
"statsServer",
"... | // Run starts the the remote enforcer proxy. | [
"Run",
"starts",
"the",
"the",
"remote",
"enforcer",
"proxy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L233-L245 |
6,942 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | initRemoteEnforcer | func (s *ProxyInfo) initRemoteEnforcer(contextID string) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.InitRequestPayload{
FqConfig: s.filterQueue,
MutualAuth: s.mutualAuth,
Validity: s.validity,
ServerID: s.serverID,
ExternalIPCacheTimeout: s.ExternalIPCacheTimeout,
PacketLogs: s.packetLogs,
Secrets: s.Secrets.PublicSecrets(),
Configuration: s.cfg,
},
}
return s.rpchdl.RemoteCall(contextID, remoteenforcer.InitEnforcer, request, resp)
} | go | func (s *ProxyInfo) initRemoteEnforcer(contextID string) error {
resp := &rpcwrapper.Response{}
request := &rpcwrapper.Request{
Payload: &rpcwrapper.InitRequestPayload{
FqConfig: s.filterQueue,
MutualAuth: s.mutualAuth,
Validity: s.validity,
ServerID: s.serverID,
ExternalIPCacheTimeout: s.ExternalIPCacheTimeout,
PacketLogs: s.packetLogs,
Secrets: s.Secrets.PublicSecrets(),
Configuration: s.cfg,
},
}
return s.rpchdl.RemoteCall(contextID, remoteenforcer.InitEnforcer, request, resp)
} | [
"func",
"(",
"s",
"*",
"ProxyInfo",
")",
"initRemoteEnforcer",
"(",
"contextID",
"string",
")",
"error",
"{",
"resp",
":=",
"&",
"rpcwrapper",
".",
"Response",
"{",
"}",
"\n\n",
"request",
":=",
"&",
"rpcwrapper",
".",
"Request",
"{",
"Payload",
":",
"&"... | // initRemoteEnforcer method makes a RPC call to the remote enforcer | [
"initRemoteEnforcer",
"method",
"makes",
"a",
"RPC",
"call",
"to",
"the",
"remote",
"enforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L248-L266 |
6,943 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | NewProxyEnforcer | func NewProxyEnforcer(
mutualAuth bool,
filterQueue *fqconfig.FilterQueue,
collector collector.EventCollector,
secrets secrets.Secrets,
serverID string,
validity time.Duration,
cmdArg string,
procMountPoint string,
ExternalIPCacheTimeout time.Duration,
packetLogs bool,
cfg *runtime.Configuration,
runtimeError chan *policy.RuntimeError,
remoteParameters *env.RemoteParameters,
) enforcer.Enforcer {
statsServersecret, err := crypto.GenerateRandomString(32)
if err != nil {
// There is a very small chance of this happening we will log an error here.
zap.L().Error("Failed to generate random secret for stats reporting", zap.Error(err))
// We will use current time as the secret
statsServersecret = time.Now().String()
}
rpcClient := rpcwrapper.NewRPCWrapper()
return &ProxyInfo{
mutualAuth: mutualAuth,
Secrets: secrets,
serverID: serverID,
validity: validity,
prochdl: processmon.New(context.Background(), remoteParameters, runtimeError, rpcClient),
rpchdl: rpcClient,
filterQueue: filterQueue,
commandArg: cmdArg,
statsServerSecret: statsServersecret,
procMountPoint: procMountPoint,
ExternalIPCacheTimeout: ExternalIPCacheTimeout,
packetLogs: packetLogs,
collector: collector,
cfg: cfg,
}
} | go | func NewProxyEnforcer(
mutualAuth bool,
filterQueue *fqconfig.FilterQueue,
collector collector.EventCollector,
secrets secrets.Secrets,
serverID string,
validity time.Duration,
cmdArg string,
procMountPoint string,
ExternalIPCacheTimeout time.Duration,
packetLogs bool,
cfg *runtime.Configuration,
runtimeError chan *policy.RuntimeError,
remoteParameters *env.RemoteParameters,
) enforcer.Enforcer {
statsServersecret, err := crypto.GenerateRandomString(32)
if err != nil {
// There is a very small chance of this happening we will log an error here.
zap.L().Error("Failed to generate random secret for stats reporting", zap.Error(err))
// We will use current time as the secret
statsServersecret = time.Now().String()
}
rpcClient := rpcwrapper.NewRPCWrapper()
return &ProxyInfo{
mutualAuth: mutualAuth,
Secrets: secrets,
serverID: serverID,
validity: validity,
prochdl: processmon.New(context.Background(), remoteParameters, runtimeError, rpcClient),
rpchdl: rpcClient,
filterQueue: filterQueue,
commandArg: cmdArg,
statsServerSecret: statsServersecret,
procMountPoint: procMountPoint,
ExternalIPCacheTimeout: ExternalIPCacheTimeout,
packetLogs: packetLogs,
collector: collector,
cfg: cfg,
}
} | [
"func",
"NewProxyEnforcer",
"(",
"mutualAuth",
"bool",
",",
"filterQueue",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"collector",
"collector",
".",
"EventCollector",
",",
"secrets",
"secrets",
".",
"Secrets",
",",
"serverID",
"string",
",",
"validity",
"time",
"... | // NewProxyEnforcer creates a new proxy to remote enforcers. | [
"NewProxyEnforcer",
"creates",
"a",
"new",
"proxy",
"to",
"remote",
"enforcers",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L269-L311 |
6,944 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | GetStats | func (r *StatsServer) GetStats(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !r.rpchdl.ProcessMessage(&req, r.secret) {
return errors.New("message sender cannot be verified")
}
payload := req.Payload.(rpcwrapper.StatsPayload)
for _, record := range payload.Flows {
r.collector.CollectFlowEvent(record)
}
for _, record := range payload.Users {
r.collector.CollectUserEvent(record)
}
return nil
} | go | func (r *StatsServer) GetStats(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !r.rpchdl.ProcessMessage(&req, r.secret) {
return errors.New("message sender cannot be verified")
}
payload := req.Payload.(rpcwrapper.StatsPayload)
for _, record := range payload.Flows {
r.collector.CollectFlowEvent(record)
}
for _, record := range payload.Users {
r.collector.CollectUserEvent(record)
}
return nil
} | [
"func",
"(",
"r",
"*",
"StatsServer",
")",
"GetStats",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"if",
"!",
"r",
".",
"rpchdl",
".",
"ProcessMessage",
"(",
"&",
"req",
",",
"r",
".",... | // GetStats is the function called from the remoteenforcer when it has new flow events to publish. | [
"GetStats",
"is",
"the",
"function",
"called",
"from",
"the",
"remoteenforcer",
"when",
"it",
"has",
"new",
"flow",
"events",
"to",
"publish",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L321-L338 |
6,945 | aporeto-inc/trireme-lib | controller/internal/enforcer/proxy/enforcerproxy.go | PostPacketEvent | func (r *StatsServer) PostPacketEvent(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !r.rpchdl.ProcessMessage(&req, r.secret) {
return errors.New("message sender cannot be verified")
}
payload := req.Payload.(rpcwrapper.DebugPacketPayload)
for _, record := range payload.PacketRecords {
r.collector.CollectPacketEvent(record)
}
return nil
} | go | func (r *StatsServer) PostPacketEvent(req rpcwrapper.Request, resp *rpcwrapper.Response) error {
if !r.rpchdl.ProcessMessage(&req, r.secret) {
return errors.New("message sender cannot be verified")
}
payload := req.Payload.(rpcwrapper.DebugPacketPayload)
for _, record := range payload.PacketRecords {
r.collector.CollectPacketEvent(record)
}
return nil
} | [
"func",
"(",
"r",
"*",
"StatsServer",
")",
"PostPacketEvent",
"(",
"req",
"rpcwrapper",
".",
"Request",
",",
"resp",
"*",
"rpcwrapper",
".",
"Response",
")",
"error",
"{",
"if",
"!",
"r",
".",
"rpchdl",
".",
"ProcessMessage",
"(",
"&",
"req",
",",
"r",... | // PostPacketEvent is called from the remote to post multiple records from the remoteenforcer | [
"PostPacketEvent",
"is",
"called",
"from",
"the",
"remote",
"to",
"post",
"multiple",
"records",
"from",
"the",
"remoteenforcer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/proxy/enforcerproxy.go#L341-L352 |
6,946 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/http.go | NewHTTPProxy | func NewHTTPProxy(
c collector.EventCollector,
puContext string,
caPool *x509.CertPool,
applicationProxy bool,
mark int,
secrets secrets.Secrets,
registry *serviceregistry.Registry,
) *Config {
return &Config{
collector: c,
puContext: puContext,
ca: caPool,
applicationProxy: applicationProxy,
mark: mark,
secrets: secrets,
localIPs: markedconn.GetInterfaces(),
registry: registry,
tlsClientConfig: &tls.Config{
RootCAs: caPool,
},
}
} | go | func NewHTTPProxy(
c collector.EventCollector,
puContext string,
caPool *x509.CertPool,
applicationProxy bool,
mark int,
secrets secrets.Secrets,
registry *serviceregistry.Registry,
) *Config {
return &Config{
collector: c,
puContext: puContext,
ca: caPool,
applicationProxy: applicationProxy,
mark: mark,
secrets: secrets,
localIPs: markedconn.GetInterfaces(),
registry: registry,
tlsClientConfig: &tls.Config{
RootCAs: caPool,
},
}
} | [
"func",
"NewHTTPProxy",
"(",
"c",
"collector",
".",
"EventCollector",
",",
"puContext",
"string",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
"applicationProxy",
"bool",
",",
"mark",
"int",
",",
"secrets",
"secrets",
".",
"Secrets",
",",
"registry",
"*... | // NewHTTPProxy creates a new instance of proxy reate a new instance of Proxy | [
"NewHTTPProxy",
"creates",
"a",
"new",
"instance",
"of",
"proxy",
"reate",
"a",
"new",
"instance",
"of",
"Proxy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/http.go#L69-L92 |
6,947 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/http.go | clientTLSConfiguration | func (p *Config) clientTLSConfiguration(conn net.Conn, originalConfig *tls.Config) (*tls.Config, error) {
if mconn, ok := conn.(*markedconn.ProxiedConnection); ok {
ip, port := mconn.GetOriginalDestination()
portContext, err := p.registry.RetrieveExposedServiceContext(ip, port, "")
if err != nil {
return nil, fmt.Errorf("Unknown service: %s", err)
}
if portContext.Service.UserAuthorizationType == policy.UserAuthorizationMutualTLS || portContext.Service.UserAuthorizationType == policy.UserAuthorizationJWT {
clientCAs := p.ca
if portContext.ClientTrustedRoots != nil {
clientCAs = portContext.ClientTrustedRoots
}
config := p.newBaseTLSConfig()
config.ClientAuth = tls.VerifyClientCertIfGiven
config.ClientCAs = clientCAs
return config, nil
}
return originalConfig, nil
}
return nil, fmt.Errorf("Invalid connection")
} | go | func (p *Config) clientTLSConfiguration(conn net.Conn, originalConfig *tls.Config) (*tls.Config, error) {
if mconn, ok := conn.(*markedconn.ProxiedConnection); ok {
ip, port := mconn.GetOriginalDestination()
portContext, err := p.registry.RetrieveExposedServiceContext(ip, port, "")
if err != nil {
return nil, fmt.Errorf("Unknown service: %s", err)
}
if portContext.Service.UserAuthorizationType == policy.UserAuthorizationMutualTLS || portContext.Service.UserAuthorizationType == policy.UserAuthorizationJWT {
clientCAs := p.ca
if portContext.ClientTrustedRoots != nil {
clientCAs = portContext.ClientTrustedRoots
}
config := p.newBaseTLSConfig()
config.ClientAuth = tls.VerifyClientCertIfGiven
config.ClientCAs = clientCAs
return config, nil
}
return originalConfig, nil
}
return nil, fmt.Errorf("Invalid connection")
} | [
"func",
"(",
"p",
"*",
"Config",
")",
"clientTLSConfiguration",
"(",
"conn",
"net",
".",
"Conn",
",",
"originalConfig",
"*",
"tls",
".",
"Config",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"if",
"mconn",
",",
"ok",
":=",
"conn",
... | // clientTLSConfiguration calculates the right certificates and requests to the clients. | [
"clientTLSConfiguration",
"calculates",
"the",
"right",
"certificates",
"and",
"requests",
"to",
"the",
"clients",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/http.go#L95-L115 |
6,948 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/http.go | newBaseTLSConfig | func (p *Config) newBaseTLSConfig() *tls.Config {
return &tls.Config{
GetCertificate: p.GetCertificateFunc(),
NextProtos: []string{"h2"},
PreferServerCipherSuites: true,
SessionTicketsDisabled: true,
CipherSuites: []uint16{
tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
},
}
} | go | func (p *Config) newBaseTLSConfig() *tls.Config {
return &tls.Config{
GetCertificate: p.GetCertificateFunc(),
NextProtos: []string{"h2"},
PreferServerCipherSuites: true,
SessionTicketsDisabled: true,
CipherSuites: []uint16{
tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
},
}
} | [
"func",
"(",
"p",
"*",
"Config",
")",
"newBaseTLSConfig",
"(",
")",
"*",
"tls",
".",
"Config",
"{",
"return",
"&",
"tls",
".",
"Config",
"{",
"GetCertificate",
":",
"p",
".",
"GetCertificateFunc",
"(",
")",
",",
"NextProtos",
":",
"[",
"]",
"string",
... | // newBaseTLSConfig creates the new basic TLS configuration for the server. | [
"newBaseTLSConfig",
"creates",
"the",
"new",
"basic",
"TLS",
"configuration",
"for",
"the",
"server",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/http.go#L118-L132 |
6,949 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/http.go | UpdateSecrets | func (p *Config) UpdateSecrets(cert *tls.Certificate, caPool *x509.CertPool, s secrets.Secrets, certPEM, keyPEM string) {
p.Lock()
defer p.Unlock()
p.cert = cert
p.ca = caPool
p.secrets = s
p.certPEM = certPEM
p.keyPEM = keyPEM
p.tlsClientConfig.RootCAs = caPool
} | go | func (p *Config) UpdateSecrets(cert *tls.Certificate, caPool *x509.CertPool, s secrets.Secrets, certPEM, keyPEM string) {
p.Lock()
defer p.Unlock()
p.cert = cert
p.ca = caPool
p.secrets = s
p.certPEM = certPEM
p.keyPEM = keyPEM
p.tlsClientConfig.RootCAs = caPool
} | [
"func",
"(",
"p",
"*",
"Config",
")",
"UpdateSecrets",
"(",
"cert",
"*",
"tls",
".",
"Certificate",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
"s",
"secrets",
".",
"Secrets",
",",
"certPEM",
",",
"keyPEM",
"string",
")",
"{",
"p",
".",
"Lock",... | // UpdateSecrets updates the secrets | [
"UpdateSecrets",
"updates",
"the",
"secrets"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/http.go#L306-L316 |
6,950 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/http/http.go | GetCertificateFunc | func (p *Config) GetCertificateFunc() func(*tls.ClientHelloInfo) (*tls.Certificate, error) {
return func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
p.RLock()
defer p.RUnlock()
// First we check if this is a direct access to the public port. In this case
// we will use the service public certificate. Otherwise, we will return the
// enforcer certificate since this is internal access.
if mconn, ok := clientHello.Conn.(*markedconn.ProxiedConnection); ok {
ip, port := mconn.GetOriginalDestination()
portContext, err := p.registry.RetrieveExposedServiceContext(ip, port, "")
if err != nil {
return nil, fmt.Errorf("service not available: %s %d", ip.String(), port)
}
service := portContext.Service
if service.PublicNetworkInfo != nil && service.PublicNetworkInfo.Ports.Min == uint16(port) && len(service.PublicServiceCertificate) > 0 {
tlsCert, err := tls.X509KeyPair(service.PublicServiceCertificate, service.PublicServiceCertificateKey)
if err != nil {
return nil, fmt.Errorf("failed to parse server certificate: %s", err)
}
return &tlsCert, nil
}
}
if p.cert != nil {
return p.cert, nil
}
return nil, fmt.Errorf("no cert available - cert is nil")
}
} | go | func (p *Config) GetCertificateFunc() func(*tls.ClientHelloInfo) (*tls.Certificate, error) {
return func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
p.RLock()
defer p.RUnlock()
// First we check if this is a direct access to the public port. In this case
// we will use the service public certificate. Otherwise, we will return the
// enforcer certificate since this is internal access.
if mconn, ok := clientHello.Conn.(*markedconn.ProxiedConnection); ok {
ip, port := mconn.GetOriginalDestination()
portContext, err := p.registry.RetrieveExposedServiceContext(ip, port, "")
if err != nil {
return nil, fmt.Errorf("service not available: %s %d", ip.String(), port)
}
service := portContext.Service
if service.PublicNetworkInfo != nil && service.PublicNetworkInfo.Ports.Min == uint16(port) && len(service.PublicServiceCertificate) > 0 {
tlsCert, err := tls.X509KeyPair(service.PublicServiceCertificate, service.PublicServiceCertificateKey)
if err != nil {
return nil, fmt.Errorf("failed to parse server certificate: %s", err)
}
return &tlsCert, nil
}
}
if p.cert != nil {
return p.cert, nil
}
return nil, fmt.Errorf("no cert available - cert is nil")
}
} | [
"func",
"(",
"p",
"*",
"Config",
")",
"GetCertificateFunc",
"(",
")",
"func",
"(",
"*",
"tls",
".",
"ClientHelloInfo",
")",
"(",
"*",
"tls",
".",
"Certificate",
",",
"error",
")",
"{",
"return",
"func",
"(",
"clientHello",
"*",
"tls",
".",
"ClientHello... | // GetCertificateFunc implements the TLS interface for getting the certificate. This
// allows us to update the certificates of the connection on the fly. | [
"GetCertificateFunc",
"implements",
"the",
"TLS",
"interface",
"for",
"getting",
"the",
"certificate",
".",
"This",
"allows",
"us",
"to",
"update",
"the",
"certificates",
"of",
"the",
"connection",
"on",
"the",
"fly",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/http/http.go#L320-L347 |
6,951 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | NewGoIPTablesProvider | func NewGoIPTablesProvider(batchTables []string) (*BatchProvider, error) {
ipt, err := iptables.New()
if err != nil {
return nil, err
}
batchTablesMap := map[string]bool{}
// We will only support the batch method if there is iptables-restore and iptables
// version 1.6.2 or better. Otherwise, we fall back to classic iptables instructions.
// This will allow us to support older kernel versions.
if restoreHasWait() {
for _, t := range batchTables {
batchTablesMap[t] = true
}
}
b := &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
}
b.commitFunc = b.restore
return b, nil
} | go | func NewGoIPTablesProvider(batchTables []string) (*BatchProvider, error) {
ipt, err := iptables.New()
if err != nil {
return nil, err
}
batchTablesMap := map[string]bool{}
// We will only support the batch method if there is iptables-restore and iptables
// version 1.6.2 or better. Otherwise, we fall back to classic iptables instructions.
// This will allow us to support older kernel versions.
if restoreHasWait() {
for _, t := range batchTables {
batchTablesMap[t] = true
}
}
b := &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
}
b.commitFunc = b.restore
return b, nil
} | [
"func",
"NewGoIPTablesProvider",
"(",
"batchTables",
"[",
"]",
"string",
")",
"(",
"*",
"BatchProvider",
",",
"error",
")",
"{",
"ipt",
",",
"err",
":=",
"iptables",
".",
"New",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"er... | // NewGoIPTablesProvider returns an IptablesProvider interface based on the go-iptables
// external package. | [
"NewGoIPTablesProvider",
"returns",
"an",
"IptablesProvider",
"interface",
"based",
"on",
"the",
"go",
"-",
"iptables",
"external",
"package",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L61-L86 |
6,952 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | NewCustomBatchProvider | func NewCustomBatchProvider(ipt BaseIPTables, commit func(buf *bytes.Buffer) error, batchTables []string) *BatchProvider {
batchTablesMap := map[string]bool{}
for _, t := range batchTables {
batchTablesMap[t] = true
}
return &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
commitFunc: commit,
}
} | go | func NewCustomBatchProvider(ipt BaseIPTables, commit func(buf *bytes.Buffer) error, batchTables []string) *BatchProvider {
batchTablesMap := map[string]bool{}
for _, t := range batchTables {
batchTablesMap[t] = true
}
return &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
commitFunc: commit,
}
} | [
"func",
"NewCustomBatchProvider",
"(",
"ipt",
"BaseIPTables",
",",
"commit",
"func",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
")",
"error",
",",
"batchTables",
"[",
"]",
"string",
")",
"*",
"BatchProvider",
"{",
"batchTablesMap",
":=",
"map",
"[",
"string",
... | // NewCustomBatchProvider is a custom batch provider wher the downstream
// iptables utility is provided by the caller. Very useful for testing
// the ACL functions with a mock. | [
"NewCustomBatchProvider",
"is",
"a",
"custom",
"batch",
"provider",
"wher",
"the",
"downstream",
"iptables",
"utility",
"is",
"provided",
"by",
"the",
"caller",
".",
"Very",
"useful",
"for",
"testing",
"the",
"ACL",
"functions",
"with",
"a",
"mock",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L91-L105 |
6,953 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | Append | func (b *BatchProvider) Append(table, chain string, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Append(table, chain, rulespec...)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
if _, ok := b.rules[table][chain]; !ok {
b.rules[table][chain] = []string{}
}
rule := strings.Join(rulespec, " ")
b.rules[table][chain] = append(b.rules[table][chain], rule)
return nil
} | go | func (b *BatchProvider) Append(table, chain string, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Append(table, chain, rulespec...)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
if _, ok := b.rules[table][chain]; !ok {
b.rules[table][chain] = []string{}
}
rule := strings.Join(rulespec, " ")
b.rules[table][chain] = append(b.rules[table][chain], rule)
return nil
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"Append",
"(",
"table",
",",
"chain",
"string",
",",
"rulespec",
"...",
"string",
")",
"error",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok... | // Append will append the provided rule to the local cache or call
// directly the iptables command depending on the table. | [
"Append",
"will",
"append",
"the",
"provided",
"rule",
"to",
"the",
"local",
"cache",
"or",
"call",
"directly",
"the",
"iptables",
"command",
"depending",
"on",
"the",
"table",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L109-L130 |
6,954 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | Insert | func (b *BatchProvider) Insert(table, chain string, pos int, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Insert(table, chain, pos, rulespec...)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
if _, ok := b.rules[table][chain]; !ok {
b.rules[table][chain] = []string{}
}
rule := strings.Join(rulespec, " ")
if pos == 1 {
b.rules[table][chain] = append([]string{rule}, b.rules[table][chain]...)
} else if pos > len(b.rules[table][chain]) {
b.rules[table][chain] = append(b.rules[table][chain], rule)
} else {
b.rules[table][chain] = append(b.rules[table][chain], "newvalue")
copy(b.rules[table][chain][pos-1:], b.rules[table][chain][pos-2:])
b.rules[table][chain][pos-1] = rule
}
return nil
} | go | func (b *BatchProvider) Insert(table, chain string, pos int, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Insert(table, chain, pos, rulespec...)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
if _, ok := b.rules[table][chain]; !ok {
b.rules[table][chain] = []string{}
}
rule := strings.Join(rulespec, " ")
if pos == 1 {
b.rules[table][chain] = append([]string{rule}, b.rules[table][chain]...)
} else if pos > len(b.rules[table][chain]) {
b.rules[table][chain] = append(b.rules[table][chain], rule)
} else {
b.rules[table][chain] = append(b.rules[table][chain], "newvalue")
copy(b.rules[table][chain][pos-1:], b.rules[table][chain][pos-2:])
b.rules[table][chain][pos-1] = rule
}
return nil
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"Insert",
"(",
"table",
",",
"chain",
"string",
",",
"pos",
"int",
",",
"rulespec",
"...",
"string",
")",
"error",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
... | // Insert will insert the rule in the corresponding position in the local
// cache or call the corresponding iptables command, depending on the table. | [
"Insert",
"will",
"insert",
"the",
"rule",
"in",
"the",
"corresponding",
"position",
"in",
"the",
"local",
"cache",
"or",
"call",
"the",
"corresponding",
"iptables",
"command",
"depending",
"on",
"the",
"table",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L134-L164 |
6,955 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | Delete | func (b *BatchProvider) Delete(table, chain string, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Delete(table, chain, rulespec...)
}
if _, ok := b.rules[table]; !ok {
return nil
}
if _, ok := b.rules[table][chain]; !ok {
return nil
}
rule := strings.Join(rulespec, " ")
for index, r := range b.rules[table][chain] {
if rule == r {
switch index {
case 0:
if len(b.rules[table][chain]) == 1 {
b.rules[table][chain] = []string{}
} else {
b.rules[table][chain] = b.rules[table][chain][1:]
}
case len(b.rules[table][chain]) - 1:
b.rules[table][chain] = b.rules[table][chain][:index]
default:
b.rules[table][chain] = append(b.rules[table][chain][:index], b.rules[table][chain][index+1:]...)
}
break
}
}
return nil
} | go | func (b *BatchProvider) Delete(table, chain string, rulespec ...string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.Delete(table, chain, rulespec...)
}
if _, ok := b.rules[table]; !ok {
return nil
}
if _, ok := b.rules[table][chain]; !ok {
return nil
}
rule := strings.Join(rulespec, " ")
for index, r := range b.rules[table][chain] {
if rule == r {
switch index {
case 0:
if len(b.rules[table][chain]) == 1 {
b.rules[table][chain] = []string{}
} else {
b.rules[table][chain] = b.rules[table][chain][1:]
}
case len(b.rules[table][chain]) - 1:
b.rules[table][chain] = b.rules[table][chain][:index]
default:
b.rules[table][chain] = append(b.rules[table][chain][:index], b.rules[table][chain][index+1:]...)
}
break
}
}
return nil
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"Delete",
"(",
"table",
",",
"chain",
"string",
",",
"rulespec",
"...",
"string",
")",
"error",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok... | // Delete will delete the rule from the local cache or the system. | [
"Delete",
"will",
"delete",
"the",
"rule",
"from",
"the",
"local",
"cache",
"or",
"the",
"system",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L167-L204 |
6,956 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | ListChains | func (b *BatchProvider) ListChains(table string) ([]string, error) {
b.Lock()
defer b.Unlock()
return b.ipt.ListChains(table)
} | go | func (b *BatchProvider) ListChains(table string) ([]string, error) {
b.Lock()
defer b.Unlock()
return b.ipt.ListChains(table)
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"ListChains",
"(",
"table",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"b",
".",
"ipt",
... | // ListChains will provide a list of the current chains. | [
"ListChains",
"will",
"provide",
"a",
"list",
"of",
"the",
"current",
"chains",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L207-L212 |
6,957 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | NewChain | func (b *BatchProvider) NewChain(table, chain string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.NewChain(table, chain)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
b.rules[table][chain] = []string{}
return nil
} | go | func (b *BatchProvider) NewChain(table, chain string) error {
b.Lock()
defer b.Unlock()
if _, ok := b.batchTables[table]; !ok {
return b.ipt.NewChain(table, chain)
}
if _, ok := b.rules[table]; !ok {
b.rules[table] = map[string][]string{}
}
b.rules[table][chain] = []string{}
return nil
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"NewChain",
"(",
"table",
",",
"chain",
"string",
")",
"error",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"b",
".",
"batchTables"... | // NewChain creates a new chain. | [
"NewChain",
"creates",
"a",
"new",
"chain",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L254-L268 |
6,958 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | Commit | func (b *BatchProvider) Commit() error {
b.Lock()
defer b.Unlock()
// We don't commit if we don't have any tables. This is old
// kernel compatibility mode.
if len(b.batchTables) == 0 {
return nil
}
buf, err := b.createDataBuffer()
if err != nil {
return fmt.Errorf("Failed to crete buffer %s", err)
}
return b.commitFunc(buf)
} | go | func (b *BatchProvider) Commit() error {
b.Lock()
defer b.Unlock()
// We don't commit if we don't have any tables. This is old
// kernel compatibility mode.
if len(b.batchTables) == 0 {
return nil
}
buf, err := b.createDataBuffer()
if err != nil {
return fmt.Errorf("Failed to crete buffer %s", err)
}
return b.commitFunc(buf)
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"Commit",
"(",
")",
"error",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"// We don't commit if we don't have any tables. This is old",
"// kernel compatibility mode.",
"if",
... | // Commit commits the rules to the system | [
"Commit",
"commits",
"the",
"rules",
"to",
"the",
"system"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L271-L287 |
6,959 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | RetrieveTable | func (b *BatchProvider) RetrieveTable() map[string]map[string][]string {
b.Lock()
defer b.Unlock()
return b.rules
} | go | func (b *BatchProvider) RetrieveTable() map[string]map[string][]string {
b.Lock()
defer b.Unlock()
return b.rules
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"RetrieveTable",
"(",
")",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"b",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"b",... | // RetrieveTable allows a caller to retrieve the final table. Mostly
// needed for debuging and unit tests. | [
"RetrieveTable",
"allows",
"a",
"caller",
"to",
"retrieve",
"the",
"final",
"table",
".",
"Mostly",
"needed",
"for",
"debuging",
"and",
"unit",
"tests",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L291-L296 |
6,960 | aporeto-inc/trireme-lib | controller/pkg/aclprovider/iptablesprovider.go | restore | func (b *BatchProvider) restore(buf *bytes.Buffer) error {
cmd := exec.Command(restoreCmd, "--wait")
cmd.Stdin = buf
out, err := cmd.CombinedOutput()
if err != nil {
again, _ := b.createDataBuffer()
zap.L().Error("Failed to execute command", zap.Error(err),
zap.ByteString("Output", out),
zap.String("Output", again.String()),
)
return fmt.Errorf("Failed to execute iptables-restore: %s", err)
}
return nil
} | go | func (b *BatchProvider) restore(buf *bytes.Buffer) error {
cmd := exec.Command(restoreCmd, "--wait")
cmd.Stdin = buf
out, err := cmd.CombinedOutput()
if err != nil {
again, _ := b.createDataBuffer()
zap.L().Error("Failed to execute command", zap.Error(err),
zap.ByteString("Output", out),
zap.String("Output", again.String()),
)
return fmt.Errorf("Failed to execute iptables-restore: %s", err)
}
return nil
} | [
"func",
"(",
"b",
"*",
"BatchProvider",
")",
"restore",
"(",
"buf",
"*",
"bytes",
".",
"Buffer",
")",
"error",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"restoreCmd",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Stdin",
"=",
"buf",
"\n",
"out",
... | // restore will save the current DB to iptables. | [
"restore",
"will",
"save",
"the",
"current",
"DB",
"to",
"iptables",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/aclprovider/iptablesprovider.go#L326-L340 |
6,961 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockNewRPCClient | func (m *testRPC) MockNewRPCClient(t *testing.T, impl func(contextID string, channel string, secret string) error) {
m.currentMocks(t).NewRPCClientMock = impl
} | go | func (m *testRPC) MockNewRPCClient(t *testing.T, impl func(contextID string, channel string, secret string) error) {
m.currentMocks(t).NewRPCClientMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockNewRPCClient",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"contextID",
"string",
",",
"channel",
"string",
",",
"secret",
"string",
")",
"error",
")",
"{",
"m",
".",
"currentMocks",
"(",
... | // MockNewRPCClient mocks the NewRPCClient function | [
"MockNewRPCClient",
"mocks",
"the",
"NewRPCClient",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L69-L71 |
6,962 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockGetRPCClient | func (m *testRPC) MockGetRPCClient(t *testing.T, impl func(contextID string) (*RPCHdl, error)) {
m.currentMocks(t).GetRPCClientMock = impl
} | go | func (m *testRPC) MockGetRPCClient(t *testing.T, impl func(contextID string) (*RPCHdl, error)) {
m.currentMocks(t).GetRPCClientMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockGetRPCClient",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"contextID",
"string",
")",
"(",
"*",
"RPCHdl",
",",
"error",
")",
")",
"{",
"m",
".",
"currentMocks",
"(",
"t",
")",
".",
"G... | // MockGetRPCClient mocks the GetRPCClient function | [
"MockGetRPCClient",
"mocks",
"the",
"GetRPCClient",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L74-L76 |
6,963 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockRemoteCall | func (m *testRPC) MockRemoteCall(t *testing.T, impl func(contextID string, methodName string, req *Request, resp *Response) error) {
m.currentMocks(t).RemoteCallMock = impl
} | go | func (m *testRPC) MockRemoteCall(t *testing.T, impl func(contextID string, methodName string, req *Request, resp *Response) error) {
m.currentMocks(t).RemoteCallMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockRemoteCall",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"contextID",
"string",
",",
"methodName",
"string",
",",
"req",
"*",
"Request",
",",
"resp",
"*",
"Response",
")",
"error",
")",
"{... | // MockRemoteCall mocks the RemoteCall function | [
"MockRemoteCall",
"mocks",
"the",
"RemoteCall",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L79-L81 |
6,964 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockDestroyRPCClient | func (m *testRPC) MockDestroyRPCClient(t *testing.T, impl func(contextID string)) {
m.currentMocks(t).DestroyRPCClientMock = impl
} | go | func (m *testRPC) MockDestroyRPCClient(t *testing.T, impl func(contextID string)) {
m.currentMocks(t).DestroyRPCClientMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockDestroyRPCClient",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"contextID",
"string",
")",
")",
"{",
"m",
".",
"currentMocks",
"(",
"t",
")",
".",
"DestroyRPCClientMock",
"=",
"impl",
"\n",
... | // MockDestroyRPCClient mocks the DestroyRPCClient function | [
"MockDestroyRPCClient",
"mocks",
"the",
"DestroyRPCClient",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L84-L86 |
6,965 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockStartServer | func (m *testRPC) MockStartServer(t *testing.T, impl func(ctx context.Context, protocol string, path string, handler interface{}) error) {
m.currentMocks(t).StartServerMock = impl
} | go | func (m *testRPC) MockStartServer(t *testing.T, impl func(ctx context.Context, protocol string, path string, handler interface{}) error) {
m.currentMocks(t).StartServerMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockStartServer",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"protocol",
"string",
",",
"path",
"string",
",",
"handler",
"interface",
"{",
"}",
")",
"e... | // MockStartServer mocks the StartServer function | [
"MockStartServer",
"mocks",
"the",
"StartServer",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L89-L92 |
6,966 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockProcessMessage | func (m *testRPC) MockProcessMessage(t *testing.T, impl func(req *Request, secret string) bool) {
m.currentMocks(t).ProcessMessageMock = impl
} | go | func (m *testRPC) MockProcessMessage(t *testing.T, impl func(req *Request, secret string) bool) {
m.currentMocks(t).ProcessMessageMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockProcessMessage",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
")",
"{",
"m",
".",
"currentMocks",
"(",
"t",
")",
".",
"Process... | // MockProcessMessage mocks the ProcessMessage function | [
"MockProcessMessage",
"mocks",
"the",
"ProcessMessage",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L95-L97 |
6,967 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockContextList | func (m *testRPC) MockContextList(t *testing.T, impl func() []string) {
m.currentMocks(t).ContextListMock = impl
} | go | func (m *testRPC) MockContextList(t *testing.T, impl func() []string) {
m.currentMocks(t).ContextListMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockContextList",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
")",
"[",
"]",
"string",
")",
"{",
"m",
".",
"currentMocks",
"(",
"t",
")",
".",
"ContextListMock",
"=",
"impl",
"\n",
"}"
] | // MockContextList mocks the ContextList function | [
"MockContextList",
"mocks",
"the",
"ContextList",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L100-L102 |
6,968 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | MockCheckValidity | func (m *testRPC) MockCheckValidity(t *testing.T, impl func(req *Request, secret string) bool) {
m.currentMocks(t).CheckValidityMock = impl
} | go | func (m *testRPC) MockCheckValidity(t *testing.T, impl func(req *Request, secret string) bool) {
m.currentMocks(t).CheckValidityMock = impl
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"MockCheckValidity",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"impl",
"func",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
")",
"{",
"m",
".",
"currentMocks",
"(",
"t",
")",
".",
"CheckVal... | // MockCheckValidity mocks the CheckValidity function | [
"MockCheckValidity",
"mocks",
"the",
"CheckValidity",
"function"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L105-L107 |
6,969 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | NewRPCClient | func (m *testRPC) NewRPCClient(contextID string, channel string, secret string) error {
if mock := m.currentMocks(nil); mock != nil && mock.NewRPCClientMock != nil {
return mock.NewRPCClientMock(contextID, channel, secret)
}
return nil
} | go | func (m *testRPC) NewRPCClient(contextID string, channel string, secret string) error {
if mock := m.currentMocks(nil); mock != nil && mock.NewRPCClientMock != nil {
return mock.NewRPCClientMock(contextID, channel, secret)
}
return nil
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"NewRPCClient",
"(",
"contextID",
"string",
",",
"channel",
"string",
",",
"secret",
"string",
")",
"error",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
";",
"mock",
"!=",
"nil",
"&&",
"m... | // NewRPCClient implements the new interface | [
"NewRPCClient",
"implements",
"the",
"new",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L110-L115 |
6,970 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | GetRPCClient | func (m *testRPC) GetRPCClient(contextID string) (*RPCHdl, error) {
if mock := m.currentMocks(nil); mock != nil && mock.GetRPCClientMock != nil {
return mock.GetRPCClientMock(contextID)
}
return nil, nil
} | go | func (m *testRPC) GetRPCClient(contextID string) (*RPCHdl, error) {
if mock := m.currentMocks(nil); mock != nil && mock.GetRPCClientMock != nil {
return mock.GetRPCClientMock(contextID)
}
return nil, nil
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"GetRPCClient",
"(",
"contextID",
"string",
")",
"(",
"*",
"RPCHdl",
",",
"error",
")",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
";",
"mock",
"!=",
"nil",
"&&",
"mock",
".",
"GetRPCC... | // GetRPCClient implements the interface with a mock | [
"GetRPCClient",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L118-L123 |
6,971 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | RemoteCall | func (m *testRPC) RemoteCall(contextID string, methodName string, req *Request, resp *Response) error {
if mock := m.currentMocks(nil); mock != nil && mock.RemoteCallMock != nil {
return mock.RemoteCallMock(contextID, methodName, req, resp)
}
return nil
} | go | func (m *testRPC) RemoteCall(contextID string, methodName string, req *Request, resp *Response) error {
if mock := m.currentMocks(nil); mock != nil && mock.RemoteCallMock != nil {
return mock.RemoteCallMock(contextID, methodName, req, resp)
}
return nil
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"RemoteCall",
"(",
"contextID",
"string",
",",
"methodName",
"string",
",",
"req",
"*",
"Request",
",",
"resp",
"*",
"Response",
")",
"error",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
... | // RemoteCall implements the interface with a mock | [
"RemoteCall",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L126-L131 |
6,972 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | DestroyRPCClient | func (m *testRPC) DestroyRPCClient(contextID string) {
if mock := m.currentMocks(nil); mock != nil && mock.DestroyRPCClientMock != nil {
mock.DestroyRPCClientMock(contextID)
return
}
} | go | func (m *testRPC) DestroyRPCClient(contextID string) {
if mock := m.currentMocks(nil); mock != nil && mock.DestroyRPCClientMock != nil {
mock.DestroyRPCClientMock(contextID)
return
}
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"DestroyRPCClient",
"(",
"contextID",
"string",
")",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
";",
"mock",
"!=",
"nil",
"&&",
"mock",
".",
"DestroyRPCClientMock",
"!=",
"nil",
"{",
"mock... | // DestroyRPCClient implements the interface with a Mock | [
"DestroyRPCClient",
"implements",
"the",
"interface",
"with",
"a",
"Mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L134-L139 |
6,973 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | CheckValidity | func (m *testRPC) CheckValidity(req *Request, secret string) bool {
if mock := m.currentMocks(nil); mock != nil && mock.DestroyRPCClientMock != nil {
return mock.CheckValidityMock(req, secret)
}
return false
} | go | func (m *testRPC) CheckValidity(req *Request, secret string) bool {
if mock := m.currentMocks(nil); mock != nil && mock.DestroyRPCClientMock != nil {
return mock.CheckValidityMock(req, secret)
}
return false
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"CheckValidity",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
";",
"mock",
"!=",
"nil",
"&&",
"mock",
".",
"DestroyRPCClie... | // CheckValidity implements the interface with a mock | [
"CheckValidity",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L142-L147 |
6,974 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | StartServer | func (m *testRPC) StartServer(ctx context.Context, protocol string, path string, handler interface{}) error {
if mock := m.currentMocks(nil); mock != nil && mock.StartServerMock != nil {
return mock.StartServerMock(ctx, protocol, path, handler)
}
return nil
} | go | func (m *testRPC) StartServer(ctx context.Context, protocol string, path string, handler interface{}) error {
if mock := m.currentMocks(nil); mock != nil && mock.StartServerMock != nil {
return mock.StartServerMock(ctx, protocol, path, handler)
}
return nil
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"StartServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"protocol",
"string",
",",
"path",
"string",
",",
"handler",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
... | // StartServer implements the interface with a mock | [
"StartServer",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L150-L155 |
6,975 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | ProcessMessage | func (m *testRPC) ProcessMessage(req *Request, secret string) bool {
if mock := m.currentMocks(nil); mock != nil && mock.ProcessMessageMock != nil {
return mock.ProcessMessageMock(req, secret)
}
return true
} | go | func (m *testRPC) ProcessMessage(req *Request, secret string) bool {
if mock := m.currentMocks(nil); mock != nil && mock.ProcessMessageMock != nil {
return mock.ProcessMessageMock(req, secret)
}
return true
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"ProcessMessage",
"(",
"req",
"*",
"Request",
",",
"secret",
"string",
")",
"bool",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"nil",
")",
";",
"mock",
"!=",
"nil",
"&&",
"mock",
".",
"ProcessMessag... | // ProcessMessage implements the interface with a mock | [
"ProcessMessage",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L158-L163 |
6,976 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | ContextList | func (m *testRPC) ContextList() []string {
if mock := m.currentMocks(m.currentTest); mock != nil && mock.ContextListMock != nil {
return mock.ContextListMock()
}
return []string{}
} | go | func (m *testRPC) ContextList() []string {
if mock := m.currentMocks(m.currentTest); mock != nil && mock.ContextListMock != nil {
return mock.ContextListMock()
}
return []string{}
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"ContextList",
"(",
")",
"[",
"]",
"string",
"{",
"if",
"mock",
":=",
"m",
".",
"currentMocks",
"(",
"m",
".",
"currentTest",
")",
";",
"mock",
"!=",
"nil",
"&&",
"mock",
".",
"ContextListMock",
"!=",
"nil",
"... | // ContextList implements the interface with a mock | [
"ContextList",
"implements",
"the",
"interface",
"with",
"a",
"mock"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L166-L171 |
6,977 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go | currentMocks | func (m *testRPC) currentMocks(t *testing.T) *mockedMethods {
m.lock.Lock()
defer m.lock.Unlock()
if t == nil {
t = m.currentTest
} else {
m.currentTest = t
}
mocks := m.mocks[t]
if mocks == nil {
mocks = &mockedMethods{}
m.mocks[t] = mocks
}
return mocks
} | go | func (m *testRPC) currentMocks(t *testing.T) *mockedMethods {
m.lock.Lock()
defer m.lock.Unlock()
if t == nil {
t = m.currentTest
} else {
m.currentTest = t
}
mocks := m.mocks[t]
if mocks == nil {
mocks = &mockedMethods{}
m.mocks[t] = mocks
}
return mocks
} | [
"func",
"(",
"m",
"*",
"testRPC",
")",
"currentMocks",
"(",
"t",
"*",
"testing",
".",
"T",
")",
"*",
"mockedMethods",
"{",
"m",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"t",
"==... | // currentMocks returns the list of current mocks | [
"currentMocks",
"returns",
"the",
"list",
"of",
"current",
"mocks"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/rpc_handlemock.go#L174-L191 |
6,978 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | NewPU | func NewPU(contextID string, puInfo *policy.PUInfo, timeout time.Duration) (*PUContext, error) {
ctx := context.Background()
ctx, cancelFunc := context.WithCancel(ctx)
pu := &PUContext{
id: contextID,
username: puInfo.Runtime.Options().UserID,
autoport: puInfo.Runtime.Options().AutoPort,
managementID: puInfo.Policy.ManagementID(),
puType: puInfo.Runtime.PUType(),
identity: puInfo.Policy.Identity(),
annotations: puInfo.Policy.Annotations(),
externalIPCache: cache.NewCacheWithExpiration("External IP Cache", timeout),
ApplicationACLs: acls.NewACLCache(),
networkACLs: acls.NewACLCache(),
mark: puInfo.Runtime.Options().CgroupMark,
scopes: puInfo.Policy.Scopes(),
CancelFunc: cancelFunc,
}
pu.CreateRcvRules(puInfo.Policy.ReceiverRules())
pu.CreateTxtRules(puInfo.Policy.TransmitterRules())
tcpPorts, udpPorts := common.ConvertServicesToProtocolPortList(puInfo.Runtime.Options().Services)
pu.tcpPorts = strings.Split(tcpPorts, ",")
pu.udpPorts = strings.Split(udpPorts, ",")
if err := pu.UpdateApplicationACLs(puInfo.Policy.ApplicationACLs()); err != nil {
return nil, err
}
if err := pu.UpdateNetworkACLs(puInfo.Policy.NetworkACLs()); err != nil {
return nil, err
}
dnsACL := puInfo.Policy.DNSNameACLs()
pu.startDNS(ctx, &dnsACL)
return pu, nil
} | go | func NewPU(contextID string, puInfo *policy.PUInfo, timeout time.Duration) (*PUContext, error) {
ctx := context.Background()
ctx, cancelFunc := context.WithCancel(ctx)
pu := &PUContext{
id: contextID,
username: puInfo.Runtime.Options().UserID,
autoport: puInfo.Runtime.Options().AutoPort,
managementID: puInfo.Policy.ManagementID(),
puType: puInfo.Runtime.PUType(),
identity: puInfo.Policy.Identity(),
annotations: puInfo.Policy.Annotations(),
externalIPCache: cache.NewCacheWithExpiration("External IP Cache", timeout),
ApplicationACLs: acls.NewACLCache(),
networkACLs: acls.NewACLCache(),
mark: puInfo.Runtime.Options().CgroupMark,
scopes: puInfo.Policy.Scopes(),
CancelFunc: cancelFunc,
}
pu.CreateRcvRules(puInfo.Policy.ReceiverRules())
pu.CreateTxtRules(puInfo.Policy.TransmitterRules())
tcpPorts, udpPorts := common.ConvertServicesToProtocolPortList(puInfo.Runtime.Options().Services)
pu.tcpPorts = strings.Split(tcpPorts, ",")
pu.udpPorts = strings.Split(udpPorts, ",")
if err := pu.UpdateApplicationACLs(puInfo.Policy.ApplicationACLs()); err != nil {
return nil, err
}
if err := pu.UpdateNetworkACLs(puInfo.Policy.NetworkACLs()); err != nil {
return nil, err
}
dnsACL := puInfo.Policy.DNSNameACLs()
pu.startDNS(ctx, &dnsACL)
return pu, nil
} | [
"func",
"NewPU",
"(",
"contextID",
"string",
",",
"puInfo",
"*",
"policy",
".",
"PUInfo",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"PUContext",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"ctx",
"... | // NewPU creates a new PU context | [
"NewPU",
"creates",
"a",
"new",
"PU",
"context"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L64-L103 |
6,979 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | RetrieveCachedExternalFlowPolicy | func (p *PUContext) RetrieveCachedExternalFlowPolicy(id string) (interface{}, error) {
return p.externalIPCache.Get(id)
} | go | func (p *PUContext) RetrieveCachedExternalFlowPolicy(id string) (interface{}, error) {
return p.externalIPCache.Get(id)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"RetrieveCachedExternalFlowPolicy",
"(",
"id",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"p",
".",
"externalIPCache",
".",
"Get",
"(",
"id",
")",
"\n",
"}"
] | // RetrieveCachedExternalFlowPolicy returns the policy for an external IP | [
"RetrieveCachedExternalFlowPolicy",
"returns",
"the",
"policy",
"for",
"an",
"external",
"IP"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L247-L249 |
6,980 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | NetworkACLPolicy | func (p *PUContext) NetworkACLPolicy(packet *packet.Packet) (report *policy.FlowPolicy, action *policy.FlowPolicy, err error) {
defer p.RUnlock()
p.RLock()
return p.networkACLs.GetMatchingAction(packet.SourceAddress(), packet.DestPort())
} | go | func (p *PUContext) NetworkACLPolicy(packet *packet.Packet) (report *policy.FlowPolicy, action *policy.FlowPolicy, err error) {
defer p.RUnlock()
p.RLock()
return p.networkACLs.GetMatchingAction(packet.SourceAddress(), packet.DestPort())
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"NetworkACLPolicy",
"(",
"packet",
"*",
"packet",
".",
"Packet",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"action",
"*",
"policy",
".",
"FlowPolicy",
",",
"err",
"error",
")",
"{",
"defer",
"p"... | // NetworkACLPolicy retrieves the policy based on ACLs | [
"NetworkACLPolicy",
"retrieves",
"the",
"policy",
"based",
"on",
"ACLs"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L252-L257 |
6,981 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | NetworkACLPolicyFromAddr | func (p *PUContext) NetworkACLPolicyFromAddr(addr net.IP, port uint16) (report *policy.FlowPolicy, action *policy.FlowPolicy, err error) {
defer p.RUnlock()
p.RLock()
return p.networkACLs.GetMatchingAction(addr, port)
} | go | func (p *PUContext) NetworkACLPolicyFromAddr(addr net.IP, port uint16) (report *policy.FlowPolicy, action *policy.FlowPolicy, err error) {
defer p.RUnlock()
p.RLock()
return p.networkACLs.GetMatchingAction(addr, port)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"NetworkACLPolicyFromAddr",
"(",
"addr",
"net",
".",
"IP",
",",
"port",
"uint16",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"action",
"*",
"policy",
".",
"FlowPolicy",
",",
"err",
"error",
")",
... | // NetworkACLPolicyFromAddr retrieve the policy given an address and port. | [
"NetworkACLPolicyFromAddr",
"retrieve",
"the",
"policy",
"given",
"an",
"address",
"and",
"port",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L260-L265 |
6,982 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | UpdateApplicationACLs | func (p *PUContext) UpdateApplicationACLs(rules policy.IPRuleList) error {
defer p.Unlock()
p.Lock()
return p.ApplicationACLs.AddRuleList(rules)
} | go | func (p *PUContext) UpdateApplicationACLs(rules policy.IPRuleList) error {
defer p.Unlock()
p.Lock()
return p.ApplicationACLs.AddRuleList(rules)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"UpdateApplicationACLs",
"(",
"rules",
"policy",
".",
"IPRuleList",
")",
"error",
"{",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"return",
"p",
".",
"ApplicationACLs",
".",
... | // UpdateApplicationACLs updates the application ACL policy | [
"UpdateApplicationACLs",
"updates",
"the",
"application",
"ACL",
"policy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L275-L279 |
6,983 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | UpdateNetworkACLs | func (p *PUContext) UpdateNetworkACLs(rules policy.IPRuleList) error {
defer p.Unlock()
p.Lock()
return p.networkACLs.AddRuleList(rules)
} | go | func (p *PUContext) UpdateNetworkACLs(rules policy.IPRuleList) error {
defer p.Unlock()
p.Lock()
return p.networkACLs.AddRuleList(rules)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"UpdateNetworkACLs",
"(",
"rules",
"policy",
".",
"IPRuleList",
")",
"error",
"{",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"return",
"p",
".",
"networkACLs",
".",
"AddRul... | // UpdateNetworkACLs updates the network ACL policy | [
"UpdateNetworkACLs",
"updates",
"the",
"network",
"ACL",
"policy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L282-L286 |
6,984 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | CacheExternalFlowPolicy | func (p *PUContext) CacheExternalFlowPolicy(packet *packet.Packet, plc interface{}) {
p.externalIPCache.AddOrUpdate(packet.SourceAddress().String()+":"+strconv.Itoa(int(packet.SourcePort())), plc)
} | go | func (p *PUContext) CacheExternalFlowPolicy(packet *packet.Packet, plc interface{}) {
p.externalIPCache.AddOrUpdate(packet.SourceAddress().String()+":"+strconv.Itoa(int(packet.SourcePort())), plc)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"CacheExternalFlowPolicy",
"(",
"packet",
"*",
"packet",
".",
"Packet",
",",
"plc",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"externalIPCache",
".",
"AddOrUpdate",
"(",
"packet",
".",
"SourceAddress",
"(",
")",
... | // CacheExternalFlowPolicy will cache an external flow | [
"CacheExternalFlowPolicy",
"will",
"cache",
"an",
"external",
"flow"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L289-L291 |
6,985 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | GetProcessKeys | func (p *PUContext) GetProcessKeys() (string, []string, []string) {
return p.mark, p.tcpPorts, p.udpPorts
} | go | func (p *PUContext) GetProcessKeys() (string, []string, []string) {
return p.mark, p.tcpPorts, p.udpPorts
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"GetProcessKeys",
"(",
")",
"(",
"string",
",",
"[",
"]",
"string",
",",
"[",
"]",
"string",
")",
"{",
"return",
"p",
".",
"mark",
",",
"p",
".",
"tcpPorts",
",",
"p",
".",
"udpPorts",
"\n",
"}"
] | // GetProcessKeys returns the cache keys for a process | [
"GetProcessKeys",
"returns",
"the",
"cache",
"keys",
"for",
"a",
"process"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L294-L296 |
6,986 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | SynServiceContext | func (p *PUContext) SynServiceContext() []byte {
p.RLock()
defer p.RUnlock()
return p.synServiceContext
} | go | func (p *PUContext) SynServiceContext() []byte {
p.RLock()
defer p.RUnlock()
return p.synServiceContext
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"SynServiceContext",
"(",
")",
"[",
"]",
"byte",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"p",
".",
"synServiceContext",
"\n",
"}"
] | // SynServiceContext returns synServiceContext | [
"SynServiceContext",
"returns",
"synServiceContext"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L299-L303 |
6,987 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | UpdateSynServiceContext | func (p *PUContext) UpdateSynServiceContext(synServiceContext []byte) {
p.Lock()
p.synServiceContext = synServiceContext
p.Unlock()
} | go | func (p *PUContext) UpdateSynServiceContext(synServiceContext []byte) {
p.Lock()
p.synServiceContext = synServiceContext
p.Unlock()
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"UpdateSynServiceContext",
"(",
"synServiceContext",
"[",
"]",
"byte",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"p",
".",
"synServiceContext",
"=",
"synServiceContext",
"\n",
"p",
".",
"Unlock",
"(",
")",
"\n",... | // UpdateSynServiceContext updates the synServiceContext | [
"UpdateSynServiceContext",
"updates",
"the",
"synServiceContext"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L306-L311 |
6,988 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | GetCachedTokenAndServiceContext | func (p *PUContext) GetCachedTokenAndServiceContext() ([]byte, []byte, error) {
p.RLock()
defer p.RUnlock()
if p.synExpiration.After(time.Now()) && len(p.synToken) > 0 {
token := make([]byte, len(p.synToken))
copy(token, p.synToken)
return token, p.synServiceContext, nil
}
return nil, nil, fmt.Errorf("expired Token")
} | go | func (p *PUContext) GetCachedTokenAndServiceContext() ([]byte, []byte, error) {
p.RLock()
defer p.RUnlock()
if p.synExpiration.After(time.Now()) && len(p.synToken) > 0 {
token := make([]byte, len(p.synToken))
copy(token, p.synToken)
return token, p.synServiceContext, nil
}
return nil, nil, fmt.Errorf("expired Token")
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"GetCachedTokenAndServiceContext",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"... | // GetCachedTokenAndServiceContext returns the cached syn packet token | [
"GetCachedTokenAndServiceContext",
"returns",
"the",
"cached",
"syn",
"packet",
"token"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L314-L326 |
6,989 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | UpdateCachedTokenAndServiceContext | func (p *PUContext) UpdateCachedTokenAndServiceContext(token []byte, serviceContext []byte) {
p.Lock()
p.synToken = token
p.synExpiration = time.Now().Add(time.Millisecond * 500)
p.synServiceContext = serviceContext
p.Unlock()
} | go | func (p *PUContext) UpdateCachedTokenAndServiceContext(token []byte, serviceContext []byte) {
p.Lock()
p.synToken = token
p.synExpiration = time.Now().Add(time.Millisecond * 500)
p.synServiceContext = serviceContext
p.Unlock()
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"UpdateCachedTokenAndServiceContext",
"(",
"token",
"[",
"]",
"byte",
",",
"serviceContext",
"[",
"]",
"byte",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n\n",
"p",
".",
"synToken",
"=",
"token",
"\n",
"p",
".",
... | // UpdateCachedTokenAndServiceContext updates the local cached token | [
"UpdateCachedTokenAndServiceContext",
"updates",
"the",
"local",
"cached",
"token"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L329-L339 |
6,990 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | Scopes | func (p *PUContext) Scopes() []string {
p.RLock()
defer p.RUnlock()
return p.scopes
} | go | func (p *PUContext) Scopes() []string {
p.RLock()
defer p.RUnlock()
return p.scopes
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"Scopes",
"(",
")",
"[",
"]",
"string",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"scopes",
"\n",
"}"
] | // Scopes returns the scopes. | [
"Scopes",
"returns",
"the",
"scopes",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L342-L347 |
6,991 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | GetJWT | func (p *PUContext) GetJWT() (string, error) {
p.RLock()
defer p.RUnlock()
if p.jwtExpiration.After(time.Now()) && len(p.jwt) > 0 {
return p.jwt, nil
}
return "", fmt.Errorf("expired token")
} | go | func (p *PUContext) GetJWT() (string, error) {
p.RLock()
defer p.RUnlock()
if p.jwtExpiration.After(time.Now()) && len(p.jwt) > 0 {
return p.jwt, nil
}
return "", fmt.Errorf("expired token")
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"GetJWT",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"p",
".",
"jwtExpiration",
".",
"After",
"(",
"time",
"... | // GetJWT retrieves the JWT if it exists in the cache. Returns error otherwise. | [
"GetJWT",
"retrieves",
"the",
"JWT",
"if",
"it",
"exists",
"in",
"the",
"cache",
".",
"Returns",
"error",
"otherwise",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L350-L359 |
6,992 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | UpdateJWT | func (p *PUContext) UpdateJWT(jwt string, expiration time.Time) {
p.Lock()
defer p.Unlock()
p.jwt = jwt
p.jwtExpiration = expiration
} | go | func (p *PUContext) UpdateJWT(jwt string, expiration time.Time) {
p.Lock()
defer p.Unlock()
p.jwt = jwt
p.jwtExpiration = expiration
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"UpdateJWT",
"(",
"jwt",
"string",
",",
"expiration",
"time",
".",
"Time",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"jwt",
"=",
"jwt",
"\n",
"p... | // UpdateJWT updates the JWT and provides a new expiration date. | [
"UpdateJWT",
"updates",
"the",
"JWT",
"and",
"provides",
"a",
"new",
"expiration",
"date",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L362-L368 |
6,993 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | createRuleDBs | func (p *PUContext) createRuleDBs(policyRules policy.TagSelectorList) *policies {
policyDB := &policies{
rejectRules: lookup.NewPolicyDB(),
observeRejectRules: lookup.NewPolicyDB(),
acceptRules: lookup.NewPolicyDB(),
observeAcceptRules: lookup.NewPolicyDB(),
observeApplyRules: lookup.NewPolicyDB(),
encryptRules: lookup.NewPolicyDB(),
}
for _, rule := range policyRules {
// Add encrypt rule to encrypt table.
if rule.Policy.Action.Encrypted() {
policyDB.encryptRules.AddPolicy(rule)
}
if rule.Policy.ObserveAction.ObserveContinue() {
if rule.Policy.Action.Accepted() {
policyDB.observeAcceptRules.AddPolicy(rule)
} else if rule.Policy.Action.Rejected() {
policyDB.observeRejectRules.AddPolicy(rule)
}
} else if rule.Policy.ObserveAction.ObserveApply() {
policyDB.observeApplyRules.AddPolicy(rule)
} else if rule.Policy.Action.Accepted() {
policyDB.acceptRules.AddPolicy(rule)
} else if rule.Policy.Action.Rejected() {
policyDB.rejectRules.AddPolicy(rule)
} else {
continue
}
}
return policyDB
} | go | func (p *PUContext) createRuleDBs(policyRules policy.TagSelectorList) *policies {
policyDB := &policies{
rejectRules: lookup.NewPolicyDB(),
observeRejectRules: lookup.NewPolicyDB(),
acceptRules: lookup.NewPolicyDB(),
observeAcceptRules: lookup.NewPolicyDB(),
observeApplyRules: lookup.NewPolicyDB(),
encryptRules: lookup.NewPolicyDB(),
}
for _, rule := range policyRules {
// Add encrypt rule to encrypt table.
if rule.Policy.Action.Encrypted() {
policyDB.encryptRules.AddPolicy(rule)
}
if rule.Policy.ObserveAction.ObserveContinue() {
if rule.Policy.Action.Accepted() {
policyDB.observeAcceptRules.AddPolicy(rule)
} else if rule.Policy.Action.Rejected() {
policyDB.observeRejectRules.AddPolicy(rule)
}
} else if rule.Policy.ObserveAction.ObserveApply() {
policyDB.observeApplyRules.AddPolicy(rule)
} else if rule.Policy.Action.Accepted() {
policyDB.acceptRules.AddPolicy(rule)
} else if rule.Policy.Action.Rejected() {
policyDB.rejectRules.AddPolicy(rule)
} else {
continue
}
}
return policyDB
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"createRuleDBs",
"(",
"policyRules",
"policy",
".",
"TagSelectorList",
")",
"*",
"policies",
"{",
"policyDB",
":=",
"&",
"policies",
"{",
"rejectRules",
":",
"lookup",
".",
"NewPolicyDB",
"(",
")",
",",
"observeReject... | // createRuleDBs creates the database of rules from the policy | [
"createRuleDBs",
"creates",
"the",
"database",
"of",
"rules",
"from",
"the",
"policy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L371-L405 |
6,994 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | CreateRcvRules | func (p *PUContext) CreateRcvRules(policyRules policy.TagSelectorList) {
p.rcv = p.createRuleDBs(policyRules)
} | go | func (p *PUContext) CreateRcvRules(policyRules policy.TagSelectorList) {
p.rcv = p.createRuleDBs(policyRules)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"CreateRcvRules",
"(",
"policyRules",
"policy",
".",
"TagSelectorList",
")",
"{",
"p",
".",
"rcv",
"=",
"p",
".",
"createRuleDBs",
"(",
"policyRules",
")",
"\n",
"}"
] | // CreateRcvRules create receive rules for this PU based on the update of the policy. | [
"CreateRcvRules",
"create",
"receive",
"rules",
"for",
"this",
"PU",
"based",
"on",
"the",
"update",
"of",
"the",
"policy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L408-L410 |
6,995 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | CreateTxtRules | func (p *PUContext) CreateTxtRules(policyRules policy.TagSelectorList) {
p.txt = p.createRuleDBs(policyRules)
} | go | func (p *PUContext) CreateTxtRules(policyRules policy.TagSelectorList) {
p.txt = p.createRuleDBs(policyRules)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"CreateTxtRules",
"(",
"policyRules",
"policy",
".",
"TagSelectorList",
")",
"{",
"p",
".",
"txt",
"=",
"p",
".",
"createRuleDBs",
"(",
"policyRules",
")",
"\n",
"}"
] | // CreateTxtRules create receive rules for this PU based on the update of the policy. | [
"CreateTxtRules",
"create",
"receive",
"rules",
"for",
"this",
"PU",
"based",
"on",
"the",
"update",
"of",
"the",
"policy",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L413-L415 |
6,996 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | searchRules | func (p *PUContext) searchRules(
policies *policies,
tags *policy.TagStore,
skipRejectPolicies bool,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
var reportingAction *policy.FlowPolicy
var packetAction *policy.FlowPolicy
if !skipRejectPolicies {
// Look for rejection rules
observeIndex, observeAction := policies.observeRejectRules.Search(tags)
if observeIndex >= 0 {
reportingAction = observeAction.(*policy.FlowPolicy)
}
index, action := policies.rejectRules.Search(tags)
if index >= 0 {
packetAction = action.(*policy.FlowPolicy)
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
}
if reportingAction == nil {
// Look for allow rules
observeIndex, observeAction := policies.observeAcceptRules.Search(tags)
if observeIndex >= 0 {
reportingAction = observeAction.(*policy.FlowPolicy)
}
}
index, action := policies.acceptRules.Search(tags)
if index >= 0 {
packetAction = action.(*policy.FlowPolicy)
// Look for encrypt rules
encryptIndex, _ := policies.encryptRules.Search(tags)
if encryptIndex >= 0 {
// Do not overwrite the action for accept rules.
finalAction := action.(*policy.FlowPolicy)
packetAction = &policy.FlowPolicy{
Action: policy.Accept | policy.Encrypt,
PolicyID: finalAction.PolicyID,
ServiceID: finalAction.ServiceID,
}
}
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
// Look for observe apply rules
observeIndex, observeAction := policies.observeApplyRules.Search(tags)
if observeIndex >= 0 {
packetAction = observeAction.(*policy.FlowPolicy)
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
// Handle default if nothing provides to drop with no policyID.
packetAction = &policy.FlowPolicy{
Action: policy.Reject,
PolicyID: "default",
}
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
} | go | func (p *PUContext) searchRules(
policies *policies,
tags *policy.TagStore,
skipRejectPolicies bool,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
var reportingAction *policy.FlowPolicy
var packetAction *policy.FlowPolicy
if !skipRejectPolicies {
// Look for rejection rules
observeIndex, observeAction := policies.observeRejectRules.Search(tags)
if observeIndex >= 0 {
reportingAction = observeAction.(*policy.FlowPolicy)
}
index, action := policies.rejectRules.Search(tags)
if index >= 0 {
packetAction = action.(*policy.FlowPolicy)
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
}
if reportingAction == nil {
// Look for allow rules
observeIndex, observeAction := policies.observeAcceptRules.Search(tags)
if observeIndex >= 0 {
reportingAction = observeAction.(*policy.FlowPolicy)
}
}
index, action := policies.acceptRules.Search(tags)
if index >= 0 {
packetAction = action.(*policy.FlowPolicy)
// Look for encrypt rules
encryptIndex, _ := policies.encryptRules.Search(tags)
if encryptIndex >= 0 {
// Do not overwrite the action for accept rules.
finalAction := action.(*policy.FlowPolicy)
packetAction = &policy.FlowPolicy{
Action: policy.Accept | policy.Encrypt,
PolicyID: finalAction.PolicyID,
ServiceID: finalAction.ServiceID,
}
}
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
// Look for observe apply rules
observeIndex, observeAction := policies.observeApplyRules.Search(tags)
if observeIndex >= 0 {
packetAction = observeAction.(*policy.FlowPolicy)
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
// Handle default if nothing provides to drop with no policyID.
packetAction = &policy.FlowPolicy{
Action: policy.Reject,
PolicyID: "default",
}
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"searchRules",
"(",
"policies",
"*",
"policies",
",",
"tags",
"*",
"policy",
".",
"TagStore",
",",
"skipRejectPolicies",
"bool",
",",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"packet",
"*",
"poli... | // searchRules searches all reject, accpet and observed rules and returns reporting and packet forwarding action | [
"searchRules",
"searches",
"all",
"reject",
"accpet",
"and",
"observed",
"rules",
"and",
"returns",
"reporting",
"and",
"packet",
"forwarding",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L418-L493 |
6,997 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | SearchTxtRules | func (p *PUContext) SearchTxtRules(
tags *policy.TagStore,
skipRejectPolicies bool,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
return p.searchRules(p.txt, tags, skipRejectPolicies)
} | go | func (p *PUContext) SearchTxtRules(
tags *policy.TagStore,
skipRejectPolicies bool,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
return p.searchRules(p.txt, tags, skipRejectPolicies)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"SearchTxtRules",
"(",
"tags",
"*",
"policy",
".",
"TagStore",
",",
"skipRejectPolicies",
"bool",
",",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"packet",
"*",
"policy",
".",
"FlowPolicy",
")",
"{... | // SearchTxtRules searches both receive and observed transmit rules and returns the index and action | [
"SearchTxtRules",
"searches",
"both",
"receive",
"and",
"observed",
"transmit",
"rules",
"and",
"returns",
"the",
"index",
"and",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L496-L501 |
6,998 | aporeto-inc/trireme-lib | controller/pkg/pucontext/pucontext.go | SearchRcvRules | func (p *PUContext) SearchRcvRules(
tags *policy.TagStore,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
return p.searchRules(p.rcv, tags, false)
} | go | func (p *PUContext) SearchRcvRules(
tags *policy.TagStore,
) (report *policy.FlowPolicy, packet *policy.FlowPolicy) {
return p.searchRules(p.rcv, tags, false)
} | [
"func",
"(",
"p",
"*",
"PUContext",
")",
"SearchRcvRules",
"(",
"tags",
"*",
"policy",
".",
"TagStore",
",",
")",
"(",
"report",
"*",
"policy",
".",
"FlowPolicy",
",",
"packet",
"*",
"policy",
".",
"FlowPolicy",
")",
"{",
"return",
"p",
".",
"searchRul... | // SearchRcvRules searches both receive and observed receive rules and returns the index and action | [
"SearchRcvRules",
"searches",
"both",
"receive",
"and",
"observed",
"receive",
"rules",
"and",
"returns",
"the",
"index",
"and",
"action"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/pucontext/pucontext.go#L504-L508 |
6,999 | aporeto-inc/trireme-lib | controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go | Register | func (r *Registry) Register(
puID string,
pu *policy.PUInfo,
puContext *pucontext.PUContext,
secrets secrets.Secrets,
) (*ServiceContext, error) {
r.Lock()
defer r.Unlock()
sctx := &ServiceContext{
PU: pu,
PUContext: puContext,
dependentServiceCache: servicecache.NewTable(),
RootCA: [][]byte{},
}
// Delete all old references first. Since the registry is locked
// nobody will be affected.
r.indexByPort.DeleteByID(puID, true)
r.indexByPort.DeleteByID(puID, false)
if err := r.updateDependentServices(sctx); err != nil {
return nil, err
}
if err := r.updateExposedServices(sctx, secrets); err != nil {
return nil, err
}
r.indexByName[puID] = sctx
return sctx, nil
} | go | func (r *Registry) Register(
puID string,
pu *policy.PUInfo,
puContext *pucontext.PUContext,
secrets secrets.Secrets,
) (*ServiceContext, error) {
r.Lock()
defer r.Unlock()
sctx := &ServiceContext{
PU: pu,
PUContext: puContext,
dependentServiceCache: servicecache.NewTable(),
RootCA: [][]byte{},
}
// Delete all old references first. Since the registry is locked
// nobody will be affected.
r.indexByPort.DeleteByID(puID, true)
r.indexByPort.DeleteByID(puID, false)
if err := r.updateDependentServices(sctx); err != nil {
return nil, err
}
if err := r.updateExposedServices(sctx, secrets); err != nil {
return nil, err
}
r.indexByName[puID] = sctx
return sctx, nil
} | [
"func",
"(",
"r",
"*",
"Registry",
")",
"Register",
"(",
"puID",
"string",
",",
"pu",
"*",
"policy",
".",
"PUInfo",
",",
"puContext",
"*",
"pucontext",
".",
"PUContext",
",",
"secrets",
"secrets",
".",
"Secrets",
",",
")",
"(",
"*",
"ServiceContext",
"... | // Register registers a new service with the registry. If the service
// already exists it updates the service with the new information, otherwise
// it creates a new service. | [
"Register",
"registers",
"a",
"new",
"service",
"with",
"the",
"registry",
".",
"If",
"the",
"service",
"already",
"exists",
"it",
"updates",
"the",
"service",
"with",
"the",
"new",
"information",
"otherwise",
"it",
"creates",
"a",
"new",
"service",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/serviceregistry/serviceregistry.go#L78-L111 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.