github.com/castai/kvisor@v1.7.1-0.20240516114728-b3572a2607b5/pkg/ebpftracer/tracer_decode_test.go (about)

     1  package ebpftracer
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"encoding/binary"
     7  	"errors"
     8  	"testing"
     9  
    10  	"github.com/castai/kvisor/pkg/ebpftracer/events"
    11  	"github.com/castai/kvisor/pkg/ebpftracer/types"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  var (
    16  	errFilterFail = errors.New("")
    17  
    18  	eventFilterFail EventFilterGenerator = GlobalEventFilterGenerator(
    19  		func(event *types.Event) error {
    20  			return errFilterFail
    21  		},
    22  	)
    23  	eventFilterPass EventFilterGenerator = GlobalEventFilterGenerator(
    24  		func(event *types.Event) error {
    25  			return FilterPass
    26  		},
    27  	)
    28  
    29  	preEventFilterFail PreEventFilterGenerator = GlobalPreEventFilterGenerator(
    30  		func(ctx *types.EventContext) error {
    31  			return errFilterFail
    32  		},
    33  	)
    34  	preEventFilterPass PreEventFilterGenerator = GlobalPreEventFilterGenerator(
    35  		func(ctx *types.EventContext) error {
    36  			return errFilterFail
    37  		},
    38  	)
    39  )
    40  
    41  func TestFilterDecodeAndExportEvent(t *testing.T) {
    42  	type testCase struct {
    43  		name        string
    44  		policy      *Policy
    45  		resultEmpty bool
    46  	}
    47  
    48  	testCases := []testCase{
    49  		{
    50  			name:        "empty policy should not drop event",
    51  			resultEmpty: false,
    52  		},
    53  		{
    54  			name: "only pre filter should drop event",
    55  			policy: &Policy{
    56  				Events: []*EventPolicy{
    57  					{
    58  						ID:                 events.TestEvent,
    59  						PreFilterGenerator: preEventFilterFail,
    60  					},
    61  				},
    62  			},
    63  			resultEmpty: true,
    64  		},
    65  		{
    66  			name: "only filter should drop event",
    67  			policy: &Policy{
    68  				Events: []*EventPolicy{
    69  					{
    70  						ID:              events.TestEvent,
    71  						FilterGenerator: eventFilterFail,
    72  					},
    73  				},
    74  			},
    75  			resultEmpty: true,
    76  		},
    77  		{
    78  			name: "pre filter false, but filter true should drop event",
    79  			policy: &Policy{
    80  				Events: []*EventPolicy{
    81  					{
    82  						ID:                 events.TestEvent,
    83  						PreFilterGenerator: preEventFilterFail,
    84  						FilterGenerator:    eventFilterPass,
    85  					},
    86  				},
    87  			},
    88  			resultEmpty: true,
    89  		},
    90  		{
    91  			name: "pre filter true, but filter false should drop event",
    92  			policy: &Policy{
    93  				Events: []*EventPolicy{
    94  					{
    95  						ID:                 events.TestEvent,
    96  						PreFilterGenerator: preEventFilterPass,
    97  						FilterGenerator:    eventFilterFail,
    98  					},
    99  				},
   100  			},
   101  			resultEmpty: true,
   102  		},
   103  		{
   104  			name: "should not process event there is no policy for",
   105  			policy: &Policy{
   106  				Events: []*EventPolicy{
   107  					{
   108  						ID: events.NetPacketDNS,
   109  					},
   110  				},
   111  			},
   112  			resultEmpty: true,
   113  		},
   114  	}
   115  
   116  	for _, tc := range testCases {
   117  		t.Run(tc.name, func(t *testing.T) {
   118  			data := buildTestEventData(t)
   119  			tracer := buildTestTracer()
   120  
   121  			if tc.policy != nil {
   122  				applyTestPolicy(tracer, tc.policy)
   123  			}
   124  
   125  			err := tracer.decodeAndExportEvent(context.TODO(), data)
   126  			require.NoError(t, err)
   127  
   128  			if tc.resultEmpty {
   129  				require.Empty(t, tracer.Events(), "there should be no event")
   130  			} else {
   131  				require.Len(t, tracer.Events(), 1, "there should be one event")
   132  			}
   133  		})
   134  
   135  	}
   136  }
   137  
   138  func buildTestEventData(t *testing.T) []byte {
   139  	ctx := types.EventContext{
   140  		EventID:     events.ProcessOomKilled,
   141  		Ts:          11,
   142  		CgroupID:    22,
   143  		ProcessorId: 5,
   144  		Pid:         543,
   145  		Tid:         77,
   146  		Ppid:        4567,
   147  		HostPid:     5430,
   148  		HostTid:     124,
   149  		HostPpid:    555,
   150  		Uid:         9876,
   151  		MntID:       1357,
   152  		PidID:       3758,
   153  		Comm:        [16]byte{1, 3, 5, 3, 1, 5, 56, 6, 7, 32, 2, 4},
   154  		UtsName:     [16]byte{5, 6, 7, 8, 9, 4, 3, 2},
   155  		Retval:      0,
   156  		StackID:     0,
   157  	}
   158  
   159  	dataBuf := &bytes.Buffer{}
   160  
   161  	err := binary.Write(dataBuf, binary.LittleEndian, ctx)
   162  	require.NoError(t, err)
   163  
   164  	// writes argument length
   165  	err = binary.Write(dataBuf, binary.LittleEndian, uint8(0))
   166  	require.NoError(t, err)
   167  
   168  	return dataBuf.Bytes()
   169  }