Implement bosh integration

.gitignore

@@ -38,3 +38,6 @@ releases/**/*.tgz
 #*
 *.pem
 *.key
+
+# pcap files
+*.pcap

ci/Dockerfile

@@ -0,0 +1,13 @@
+# Dockerfile for image cf-routing.common.repositories.cloud.sap/pcap-release-testflight
+FROM bosh/integration:main
+
+ARG GINKGO_VERSION=latest
+ARG GOLANGCILINT_VERSION=latest
+RUN apt-get update && apt-get install -y libpcap-dev && rm -rf /var/lib/apt/lists/*
+
+RUN rm -rf /usr/local/go
+COPY --from=golang:1.20 /usr/local/go/ /usr/local/go/
+ENV GOPATH=/go PATH=${PATH}:/go/bin
+
+RUN go install "github.com/onsi/ginkgo/v2/ginkgo@${GINKGO_VERSION}" \
+ && go install "github.com/golangci/golangci-lint/cmd/golangci-lint@${GOLANGCILINT_VERSION}"

ci/pipeline.yml

@@ -19,8 +19,10 @@ jobs:
               image_resource:
                 type: docker-image
                 source:
-                  repository: bosh/integration
+                  repository: cf-routing.common.repositories.cloud.sap/pcap-release-testflight
                   tag: latest
+                  username: ((docker.username))
+                  password: ((docker.password))
               inputs:
                 - { name: git }
               caches:
@@ -37,8 +39,10 @@ jobs:
               image_resource:
                 type: docker-image
                 source:
-                  repository: bosh/integration
+                  repository: cf-routing.common.repositories.cloud.sap/pcap-release-testflight
                   tag: latest
+                  username: ((docker.username))
+                  password: ((docker.password))
               inputs:
                 - { name: git }
 
@@ -75,8 +79,10 @@ jobs:
               image_resource:
                 type: docker-image
                 source:
-                  repository: bosh/integration
+                  repository: cf-routing.common.repositories.cloud.sap/pcap-release-testflight
                   tag: latest
+                  username: ((docker.username))
+                  password: ((docker.password))
               inputs:
                 - { name: git-pull-requests }
               caches:
@@ -93,8 +99,10 @@ jobs:
               image_resource:
                 type: docker-image
                 source:
-                  repository: bosh/integration
+                  repository: cf-routing.common.repositories.cloud.sap/pcap-release-testflight
                   tag: latest
+                  username: ((docker.username))
+                  password: ((docker.password))
               inputs:
                 - { name: git-pull-requests }
               caches:

ci/scripts/lint

@@ -1,9 +1,6 @@
 #!/bin/bash
-
 set -euo pipefail
 
-apt-get update && apt-get install -y libpcap-dev # TODO: remove and move to dockerfile
-
 cd "${REPO_ROOT}"
 
 echo "> Running 'bundle exec rake lint'"
@@ -13,4 +10,5 @@ bundle exec rake lint
 echo "> Running 'go vet'"
 pushd src/pcap
   go vet ./...
+  golangci-lint run
 popd

ci/scripts/unit-tests

@@ -2,8 +2,6 @@
 
 set -euo pipefail
 
-apt-get update && apt-get install -y libpcap-dev # TODO: remove and move to dockerfile
-
 cd "${REPO_ROOT}"
 
 echo "> Running 'bundle exec rake spec'"
@@ -12,15 +10,10 @@ bundle exec rake spec
 
 echo "> Running unit tests"
 pushd src/pcap
-  go test $(go list ./... | grep -v /integrationtests)
+  go test -count=1 -v $(go list ./... | grep -v test/integration)
 popd
 
-echo "> Running integration tests"
-pushd src/pcap/integrationtests
-  mkdir /go
-  export GOPATH=/go
-  go install "github.com/onsi/ginkgo/v2/ginkgo@latest"
-  export PATH=$PATH:$GOPATH/bin
-  ginkgo version
+echo "> Running integration tests (ginkgo)"
+pushd src/pcap/test/integration
   ginkgo -r -trace -vv
 popd

packages/pcap-agent/packaging

@@ -8,7 +8,7 @@ set -e
 # $BOSH_COMPILE_TARGET - where this package & spec'd source files are available
 # $BOSH_INSTALL_TARGET - where you copy/install files to be included in package
 
-tar xzf golang/go1.18.5.linux-amd64.tar.gz
+tar xzf golang/go1.20.2.linux-amd64.tar.gz
 export GOROOT="${BOSH_COMPILE_TARGET}/go"
 export PATH="${PATH}:${GOROOT}/bin"
 

packages/pcap-api/packaging

@@ -5,7 +5,7 @@ set -e
 # $BOSH_INSTALL_TARGET - where you copy/install files to be included in package
 
 # FIXME: Adjust to vendored BOSH package
-tar xzf golang/go1.18.5.linux-amd64.tar.gz
+tar xzf golang/go1.20.2.linux-amd64.tar.gz
 export GOROOT=$BOSH_COMPILE_TARGET/go
 
 # TODO: maybe these are not needed? Where does this get executed?

src/pcap/Dockerfile

@@ -0,0 +1,5 @@
+FROM golang:1.20-bullseye
+
+RUN apt update && apt install libpcap-dev -y
+
+

src/pcap/README.md

@@ -32,3 +32,49 @@ Install `ChmodBPF`, available as part of Wireshark.
 The path to the installer can be found in Wireshark > About Wireshark > Folders, MacOS Extras.
 
 The installer is called `Install ChmodBPF.pkg`.
+
+### Running the tests on MacOS
+
+All unit tests can be run locally via `go test`. The integration tests are included in `go test ./...` however and require some special handling.
+
+The integration tests open mock servers on different IPs on the loopback device in the CIDR `127.0.0.0/8`.
+MacOS does not by default support addresses other than `127.0.0.1`. It can be configured via aliases, but attempts to do so have not led to successful test execution.
+
+Instead, a Dockerfile and docker-compose file are provided, which will automatically execute all tests (go test and ginkgo tests via test suite).
+
+```shell
+cd src/pcap
+# the dockerfile is relative to src/pcap and mounts the current code as volume into the container.
+docker compose up
+```
+
+This will build the image from `Dockerfile` and run `go test -v ./...`. This should give you confidence in the tests completing successfully.
+
+### Running in IntelliJ
+
+Using the Dockerfile or Docker Compose file, you can also run the tests using the Go integration in IntelliJ.
+
+When selecting the run configuration, set up a Docker run target, either with Docker or Docker Compose. [Documentation on setting up run targets](https://www.jetbrains.com/help/idea/run-targets.html#target-types) os available from JetBrains.
+
+### Running Ginkgo Tests in IntelliJ and Docker
+
+There is a [Ginkgo plugin for IntelliJ](https://plugins.jetbrains.com/plugin/17554-ginkgo), which helps develop ginkgo tests. It can be used to visualize the structure of the test file (via the Structure view) and execute specific tests in Focus mode.
+
+Some of the integration tests require the aforementioned multiple IP addresses and will not run directly. The Ginkgo plugin does unfortunately not integrate with run targets.
+
+A run configuration with `go test` can be created, which will call the Ginkgo tests via Test Suite integration.
+Furthermore, Ginkgo command line flags can be passed on to this command as well.
+
+When developing Ginkgo tests, you often want to execute a subset of tests in Focus mode. By adding the `-ginkgo.focus "Your ginkgo focus test expression"` flag to the `go test` command, you can still use focus mode.
+
+Example:
+
+```
+go test github.com/cloudfoundry/pcap-release/src/pcap/test/integration -test.v -ginkgo.focus="Some Test Names"
+```
+
+You can configure an appropriate run configuration with a Docker based run target, as shown in the screenshot below.
+
+**Important:** Select the "Build on remote Target" checkbox as cross-compiling pcap-release with libpcap is not easily possible.
+
+![Build configuration in IntelliJ](docs/run-config.png)

src/pcap/agent.go

@@ -93,7 +93,7 @@ func (a *Agent) Capture(stream Agent_CaptureServer) (err error) {
 		}
 	}()
 
-	ctx, cancel := WithCancelCause(stream.Context())
+	ctx, cancel := context.WithCancelCause(stream.Context())
 	defer cancel(nil)
 
 	ctx, log = setVcapID(ctx, log, nil)
@@ -143,7 +143,7 @@ func (a *Agent) Capture(stream Agent_CaptureServer) (err error) {
 		<-ctx.Done()
 	}
 
-	err = Cause(ctx)
+	err = context.Cause(ctx)
 	// Cancelling the context with nil causes context.Cancelled to be set
 	// which is a non-error in our case.
 	if err != nil && !errors.Is(err, context.Canceled) {
@@ -216,7 +216,7 @@ type pcapHandle interface {
 // channel. If the given context errors the loop breaks with the next read.
 // If an error is encountered while reading packets the cancel function is
 // called and the loop is stopped.
-func readPackets(ctx context.Context, cancel CancelCauseFunc, handle pcapHandle, bufSize int) <-chan *CaptureResponse {
+func readPackets(ctx context.Context, cancel context.CancelCauseFunc, handle pcapHandle, bufSize int) <-chan *CaptureResponse {
 	out := make(chan *CaptureResponse, bufSize)
 
 	go func() {
@@ -234,13 +234,13 @@ func readPackets(ctx context.Context, cancel CancelCauseFunc, handle pcapHandle,
 				return
 			}
 
-			data, _, err := handle.ReadPacketData()
+			data, captureInfo, err := handle.ReadPacketData()
 			if err != nil {
 				cancel(fmt.Errorf("read packet: %w", err))
 				return
 			}
 
-			out <- newPacketResponse(data)
+			out <- newPacketResponse(data, captureInfo)
 		}
 	}()
 
@@ -260,7 +260,7 @@ type agentRequestReceiver interface {
 // agentStopCmd reads the next message from the stream. It ensures that the message
 // has a payload of StopAgentCapture. If any error is encountered or the payload is
 // of a different type an appropriate cause is set and the cancel function is called.
-func agentStopCmd(cancel CancelCauseFunc, stream agentRequestReceiver) {
+func agentStopCmd(cancel context.CancelCauseFunc, stream agentRequestReceiver) {
 	go func() {
 		msg, err := stream.Recv()
 		if err != nil {

src/pcap/agent_test.go

@@ -70,11 +70,11 @@ func TestAgentStopCmd(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := context.Background()
-			ctx, cancel := WithCancelCause(ctx)
+			ctx, cancel := context.WithCancelCause(ctx)
 			agentStopCmd(cancel, test.recv)
 			<-ctx.Done()
 
-			err := Cause(ctx)
+			err := context.Cause(ctx)
 
 			if (err != nil) != test.wantErr {
 				t.Errorf("wantErr = %v, error = %v", test.wantErr, err)
@@ -136,7 +136,7 @@ func TestReadPackets(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := context.Background()
-			ctx, cancel := WithCancelCause(ctx)
+			ctx, cancel := context.WithCancelCause(ctx)
 			if test.contextCancelled {
 				// cancel context before read packets in order to get edge case
 				cancel(errContextCancelled)
@@ -146,7 +146,7 @@ func TestReadPackets(t *testing.T) {
 
 			<-ctx.Done()
 
-			err := Cause(ctx)
+			err := context.Cause(ctx)
 			if err != nil && !errors.Is(err, test.expectedErr) && !errors.Is(err, errTestEnded) {
 				t.Errorf("expectedErr = %v, got err = %v", test.expectedErr, err)
 			}