DevFW-CICD/ingress-nginx-helm
16
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix errcheck warnings

Browse source 
Signed-off-by: z1cheng <imchench@gmail.com>
This commit is contained in:
z1cheng 2023-06-28 16:10:39 +00:00 committed by k8s-infra-cherrypick-robot
parent 236a41a23b
commit 2bbd69e0d9
27 changed files with 207 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cmd/plugin/commands/certs/certs.go
View file

@ -46,7 +46,9 @@ func CreateCommand(flags *genericclioptions.ConfigFlags) *cobra.Command {
}
cmd.Flags().String("host", "", "Get the cert for this hostname")
cobra.MarkFlagRequired(cmd.Flags(), "host")
if err := cobra.MarkFlagRequired(cmd.Flags(), "host"); err != nil {
fmt.Printf("error marking flag as required: %v", err)
}
pod = util.AddPodFlag(cmd)
deployment = util.AddDeploymentFlag(cmd)
selector = util.AddSelectorFlag(cmd)

6
cmd/plugin/kubectl/kubectl.go
View file

@ -77,7 +77,11 @@ func execToWriter(args []string, writer io.Writer) error {
return err
}
go io.Copy(writer, op)
go func () {
if _, err := io.Copy(writer, op); err != nil {
fmt.Printf("Error copying output: %v\n", err)
}
}()
err = cmd.Run()
if err != nil {
return err

4
images/fastcgi-helloserver/rootfs/main.go
View file

@ -26,5 +26,7 @@ func main() {
if err != nil {
panic(err)
}
fcgi.Serve(l, nil)
if err := fcgi.Serve(l, nil); err != nil {
panic(err)
}
}

2
images/kube-webhook-certgen/rootfs/pkg/k8s/k8s_test.go
View file

@ -4,7 +4,7 @@ import (
"bytes"
"context"
"errors"
"math/rand"
"crypto/rand"
"testing"
"time"

8
internal/admission/controller/main_test.go
View file

@ -114,7 +114,9 @@ func TestHandleAdmission(t *testing.T) {
err: fmt.Errorf("this is a test error"),
}
adm.HandleAdmission(review)
if _, err := adm.HandleAdmission(review); err != nil {
t.Errorf("unexpected error: %v", err)
}
if review.Response.Allowed {
t.Fatalf("when the checker returns an error, the request should not be allowed")
}
@ -124,7 +126,9 @@ func TestHandleAdmission(t *testing.T) {
err: nil,
}
adm.HandleAdmission(review)
if _, err := adm.HandleAdmission(review); err != nil {
t.Errorf("unexpected error: %v", err)
}
if !review.Response.Allowed {
t.Fatalf("when the checker returns no error, the request should be allowed")
}

4
internal/admission/controller/server.go
View file

@ -31,7 +31,9 @@ var (
)
func init() {
admissionv1.AddToScheme(scheme)
if err := admissionv1.AddToScheme(scheme); err != nil {
klog.ErrorS(err, "Failed to add scheme")
}
}
// AdmissionController checks if an object

28
internal/ingress/controller/checker_test.go
View file

@ -76,7 +76,10 @@ func TestNginxCheck(t *testing.T) {
})
// create pid file
os.MkdirAll("/tmp/nginx", file.ReadWriteByUser)
if err := os.MkdirAll("/tmp/nginx", file.ReadWriteByUser); err != nil {
t.Errorf("unexpected error creating pid file: %v", err)
}
pidFile, err := os.Create(nginx.PID)
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -90,14 +93,25 @@ func TestNginxCheck(t *testing.T) {
// start dummy process to use the PID
cmd := exec.Command("sleep", "3600")
cmd.Start()
if err := cmd.Start(); err != nil {
t.Errorf("unexpected error: %v", err)
}
pid := cmd.Process.Pid
defer cmd.Process.Kill()
defer func() {
if err := cmd.Process.Kill(); err != nil {
t.Errorf("unexpected error killing the process: %v", err)
}
}()
go func() {
cmd.Wait()
if err := cmd.Wait(); err != nil {
t.Errorf("unexpected error waiting for the process: %v", err)
}
}()
pidFile.Write([]byte(fmt.Sprintf("%v", pid)))
if _, err := pidFile.Write([]byte(fmt.Sprintf("%v", pid))); err != nil {
t.Errorf("unexpected error writing the pid file: %v", err)
}
pidFile.Close()
healthz.InstallPathHandler(mux, tt.healthzPath, n)
@ -109,7 +123,9 @@ func TestNginxCheck(t *testing.T) {
})
// pollute pid file
pidFile.Write([]byte("999999"))
if _, err := pidFile.Write([]byte("999999")); err != nil {
t.Errorf("unexpected error polluting the pid file: %v", err)
}
pidFile.Close()
t.Run("bad pid", func(t *testing.T) {

13
internal/ingress/controller/controller_test.go
View file

@ -158,7 +158,7 @@ func (fakeTemplate) Write(conf ngx_config.TemplateConfig) ([]byte, error) {
func TestCheckIngress(t *testing.T) {
defer func() {
filepath.Walk(os.TempDir(), func(path string, info os.FileInfo, err error) error {
err := filepath.Walk(os.TempDir(), func(path string, info os.FileInfo, err error) error {
if info.IsDir() && os.TempDir() != path {
return filepath.SkipDir
}
@ -167,6 +167,9 @@ func TestCheckIngress(t *testing.T) {
}
return nil
})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
}()
err := file.CreateRequiredDirectories()
@ -176,9 +179,13 @@ func TestCheckIngress(t *testing.T) {
// Ensure no panic with wrong arguments
var nginx *NGINXController
nginx.CheckIngress(nil)
if err := nginx.CheckIngress(nil); err != nil {
t.Errorf("unexpected error: %v", err)
}
nginx = newNGINXController(t)
nginx.CheckIngress(nil)
if err := nginx.CheckIngress(nil); err != nil {
t.Errorf("unexpected error: %v", err)
}
nginx.metricCollector = metric.DummyCollector{}
nginx.t = fakeTemplate{}

20
internal/ingress/controller/store/endpointslice_test.go
View file

@ -59,7 +59,9 @@ func TestEndpointSliceLister(t *testing.T) {
},
},
}
el.Add(endpointSlice)
if err := el.Add(endpointSlice); err != nil {
t.Errorf("unexpected error %v", err)
}
endpointSlice = &discoveryv1.EndpointSlice{
ObjectMeta: metav1.ObjectMeta{
Namespace: "namespace",
@ -69,7 +71,9 @@ func TestEndpointSliceLister(t *testing.T) {
},
},
}
el.Add(endpointSlice)
if err := el.Add(endpointSlice); err != nil {
t.Errorf("unexpected error %v", err)
}
endpointSlice = &discoveryv1.EndpointSlice{
ObjectMeta: metav1.ObjectMeta{
Namespace: "namespace",
@ -79,7 +83,9 @@ func TestEndpointSliceLister(t *testing.T) {
},
},
}
el.Add(endpointSlice)
if err := el.Add(endpointSlice); err != nil {
t.Errorf("unexpected error %v", err)
}
eps, err := el.MatchByKey(key)
if err != nil {
@ -108,7 +114,9 @@ func TestEndpointSliceLister(t *testing.T) {
},
},
}
el.Add(endpointSlice)
if err := el.Add(endpointSlice); err != nil {
t.Errorf("unexpected error %v", err)
}
endpointSlice2 := &discoveryv1.EndpointSlice{
ObjectMeta: metav1.ObjectMeta{
Namespace: ns2,
@ -118,7 +126,9 @@ func TestEndpointSliceLister(t *testing.T) {
},
},
}
el.Add(endpointSlice2)
if err := el.Add(endpointSlice2); err != nil {
t.Errorf("unexpected error %v", err)
}
eps, err := el.MatchByKey(key)
if err != nil {
t.Errorf("unexpeted error %v", err)

31
internal/ingress/controller/store/store.go
View file

@ -404,7 +404,10 @@ func New(
return
}
store.listers.IngressWithAnnotation.Delete(ing)
if err := store.listers.IngressWithAnnotation.Delete(ing); err != nil {
klog.ErrorS(err, "Error while deleting ingress from store", "ingress", klog.KObj(ing))
return
}
key := k8s.MetaNamespaceKey(ing)
store.secretIngressMap.Delete(key)
@ -793,14 +796,26 @@ func New(
},
}
store.informers.Ingress.AddEventHandler(ingEventHandler)
if !icConfig.IgnoreIngressClass {
store.informers.IngressClass.AddEventHandler(ingressClassEventHandler)
if _, err := store.informers.Ingress.AddEventHandler(ingEventHandler); err != nil {
klog.Errorf("Error adding ingress event handler: %v", err)
}
if !icConfig.IgnoreIngressClass {
if _, err := store.informers.IngressClass.AddEventHandler(ingressClassEventHandler); err != nil {
klog.Errorf("Error adding ingress class event handler: %v", err)
}
}
if _, err := store.informers.EndpointSlice.AddEventHandler(epsEventHandler); err != nil {
klog.Errorf("Error adding endpoint slice event handler: %v", err)
}
if _, err := store.informers.Secret.AddEventHandler(secrEventHandler); err != nil {
klog.Errorf("Error adding secret event handler: %v", err)
}
if _, err := store.informers.ConfigMap.AddEventHandler(cmEventHandler); err != nil {
klog.Errorf("Error adding configmap event handler: %v", err)
}
if _, err := store.informers.Service.AddEventHandler(serviceHandler); err != nil {
klog.Errorf("Error adding service event handler: %v", err)
}
store.informers.EndpointSlice.AddEventHandler(epsEventHandler)
store.informers.Secret.AddEventHandler(secrEventHandler)
store.informers.ConfigMap.AddEventHandler(cmEventHandler)
store.informers.Service.AddEventHandler(serviceHandler)
// do not wait for informers to read the configmap configuration
ns, name, _ := k8s.ParseNameNS(configmap)

40
internal/ingress/controller/store/store_test.go
View file

@ -92,7 +92,11 @@ func TestStore(t *testing.T) {
emptySelector, _ := labels.Parse("")
defer te.Stop()
defer func() {
if err := te.Stop(); err != nil {
t.Errorf("error: %v", err)
}
}()
clientSet, err := kubernetes.NewForConfig(cfg)
if err != nil {
@ -1377,14 +1381,18 @@ func TestUpdateSecretIngressMap(t *testing.T) {
Namespace: "testns",
},
}
s.listers.Ingress.Add(ingTpl)
if err := s.listers.Ingress.Add(ingTpl); err != nil {
t.Errorf("error adding the Ingress template: %v", err)
}
t.Run("with TLS secret", func(t *testing.T) {
ing := ingTpl.DeepCopy()
ing.Spec = networking.IngressSpec{
TLS: []networking.IngressTLS{{SecretName: "tls"}},
}
s.listers.Ingress.Update(ing)
if err := s.listers.Ingress.Update(ing); err != nil {
t.Errorf("error updating the Ingress: %v", err)
}
s.updateSecretIngressMap(ing)
if l := s.secretIngressMap.Len(); !(l == 1 && s.secretIngressMap.Has("testns/tls")) {
@ -1397,7 +1405,9 @@ func TestUpdateSecretIngressMap(t *testing.T) {
ing.ObjectMeta.SetAnnotations(map[string]string{
parser.GetAnnotationWithPrefix("auth-secret"): "auth",
})
s.listers.Ingress.Update(ing)
if err := s.listers.Ingress.Update(ing); err != nil {
t.Errorf("error updating the Ingress: %v", err)
}
s.updateSecretIngressMap(ing)
if l := s.secretIngressMap.Len(); !(l == 1 && s.secretIngressMap.Has("testns/auth")) {
@ -1410,7 +1420,9 @@ func TestUpdateSecretIngressMap(t *testing.T) {
ing.ObjectMeta.SetAnnotations(map[string]string{
parser.GetAnnotationWithPrefix("auth-secret"): "otherns/auth",
})
s.listers.Ingress.Update(ing)
if err := s.listers.Ingress.Update(ing); err != nil {
t.Errorf("error updating the Ingress: %v", err)
}
s.updateSecretIngressMap(ing)
if l := s.secretIngressMap.Len(); !(l == 1 && s.secretIngressMap.Has("otherns/auth")) {
@ -1423,7 +1435,9 @@ func TestUpdateSecretIngressMap(t *testing.T) {
ing.ObjectMeta.SetAnnotations(map[string]string{
parser.GetAnnotationWithPrefix("auth-secret"): "ns/name/garbage",
})
s.listers.Ingress.Update(ing)
if err := s.listers.Ingress.Update(ing); err != nil {
t.Errorf("error updating the Ingress: %v", err)
}
s.updateSecretIngressMap(ing)
if l := s.secretIngressMap.Len(); l != 0 {
@ -1457,7 +1471,9 @@ func TestListIngresses(t *testing.T) {
},
},
}
s.listers.IngressWithAnnotation.Add(ingressToIgnore)
if err := s.listers.IngressWithAnnotation.Add(ingressToIgnore); err != nil {
t.Errorf("error adding the Ingress: %v", err)
}
ingressWithoutPath := &ingress.Ingress{
Ingress: networking.Ingress{
@ -1492,8 +1508,9 @@ func TestListIngresses(t *testing.T) {
},
},
}
s.listers.IngressWithAnnotation.Add(ingressWithoutPath)
if err := s.listers.IngressWithAnnotation.Add(ingressWithoutPath); err != nil {
t.Errorf("error adding the Ingress: %v", err)
}
ingressWithNginxClassAnnotation := &ingress.Ingress{
Ingress: networking.Ingress{
ObjectMeta: metav1.ObjectMeta{
@ -1531,8 +1548,9 @@ func TestListIngresses(t *testing.T) {
},
},
}
s.listers.IngressWithAnnotation.Add(ingressWithNginxClassAnnotation)
if err := s.listers.IngressWithAnnotation.Add(ingressWithNginxClassAnnotation); err != nil {
t.Errorf("error adding the Ingress: %v", err)
}
ingresses := s.ListIngresses()
if s := len(ingresses); s != 3 {

4
internal/ingress/controller/template/template_test.go
View file

@ -767,7 +767,9 @@ func BenchmarkTemplateWithData(b *testing.B) {
}
for i := 0; i < b.N; i++ {
ngxTpl.Write(dat)
if _, err := ngxTpl.Write(dat); err != nil {
b.Errorf("unexpected error writing template: %v", err)
}
}
}

10
internal/ingress/metric/collectors/process_test.go
View file

@ -48,7 +48,10 @@ func TestProcessCollector(t *testing.T) {
done := make(chan struct{})
go func() {
cmd.Wait()
err = cmd.Wait()
if err != nil {
t.Errorf("unexpected error waiting for dummy process: %v", err)
}
status := cmd.ProcessState.Sys().(syscall.WaitStatus)
if status.Signaled() {
t.Logf("Signal: %v", status.Signal())
@ -69,8 +72,11 @@ func TestProcessCollector(t *testing.T) {
defer func() {
cm.Stop()
cmd.Process.Kill()
err = cmd.Process.Kill()
<-done
if err != nil {
t.Errorf("unexpected error killing dummy process: %v", err)
}
close(done)
}()

4
internal/ingress/metric/collectors/socket_test.go
View file

@ -58,7 +58,9 @@ func TestNewUDPLogListener(t *testing.T) {
}()
conn, _ := net.Dial("unix", tmpFile)
conn.Write([]byte("message"))
if _, err := conn.Write([]byte("message")); err != nil {
t.Errorf("unexpected error writing to unix socket: %v", err)
}
conn.Close()
time.Sleep(1 * time.Millisecond)

5
internal/ingress/status/status.go
View file

@ -95,10 +95,13 @@ func (s statusSync) Run(stopCh chan struct{}) {
// when this instance is the leader we need to enqueue
// an item to trigger the update of the Ingress status.
wait.PollUntil(time.Duration(UpdateInterval)*time.Second, func() (bool, error) {
err := wait.PollUntil(time.Duration(UpdateInterval)*time.Second, func() (bool, error) {
s.syncQueue.EnqueueTask(task.GetDummyObject("sync status"))
return false, nil
}, stopCh)
if err != nil {
klog.ErrorS(err, "error running poll")
}
}
// Shutdown stops the sync. In case the instance is the leader it will remove the current IP

4
internal/ingress/status/status_test.go
View file

@ -325,7 +325,9 @@ func TestStatusActions(t *testing.T) {
// wait for the election
time.Sleep(100 * time.Millisecond)
// execute sync
fk.sync("just-test")
if err := fk.sync("just-test"); err != nil {
t.Errorf("unexpected error: %v", err)
}
// PublishService is empty, so the running address is: ["11.0.0.2"]
// after updated, the ingress's ip should only be "11.0.0.2"
newIPs := []networking.IngressLoadBalancerIngress{{

5
internal/net/dns/dns_test.go
View file

@ -40,13 +40,16 @@ func TestGetDNSServers(t *testing.T) {
defer f.Close()
defer os.Remove(f.Name())
os.WriteFile(f.Name(), []byte(`
err = os.WriteFile(f.Name(), []byte(`
# comment
; comment
nameserver 2001:4860:4860::8844
nameserver 2001:4860:4860::8888
nameserver 8.8.8.8
`), file.ReadWriteByUser)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
defResolvConf = f.Name()
s, err = GetSystemNameServers()

8
internal/net/ssl/ssl_test.go
View file

@ -397,7 +397,9 @@ func newFakeCertificate(t *testing.T) ([]byte, string, string) {
t.Errorf("failed to write test key: %v", err)
}
certFile.Write(cert)
if _, err := certFile.Write(cert); err != nil {
t.Errorf("failed to write cert: %v", err)
}
defer certFile.Close()
keyFile, err := os.CreateTemp("", "key-")
@ -405,7 +407,9 @@ func newFakeCertificate(t *testing.T) ([]byte, string, string) {
t.Errorf("failed to write test key: %v", err)
}
keyFile.Write(key)
if _, err := keyFile.Write(key); err != nil {
t.Errorf("failed to write key: %v", err)
}
defer keyFile.Close()
return cert, certFile.Name(), keyFile.Name()

13
pkg/flags/flags.go
View file

@ -228,14 +228,19 @@ https://blog.maxmind.com/2019/12/18/significant-changes-to-accessing-and-using-g
flags.IntVar(&nginx.MaxmindRetriesCount, "maxmind-retries-count", 1, "Number of attempts to download the GeoIP DB.")
flags.DurationVar(&nginx.MaxmindRetriesTimeout, "maxmind-retries-timeout", time.Second*0, "Maxmind downloading delay between 1st and 2nd attempt, 0s - do not retry to download if something went wrong.")
flag.Set("logtostderr", "true")
if err := flag.Set("logtostderr", "true"); err != nil {
return false, nil, err
}
flags.AddGoFlagSet(flag.CommandLine)
flags.Parse(os.Args)
if err := flags.Parse(os.Args); err != nil {
return false, nil, err
}
// Workaround for this issue:
// https://github.com/kubernetes/kubernetes/issues/17162
flag.CommandLine.Parse([]string{})
if err := flag.CommandLine.Parse([]string{}); err != nil {
return false, nil, err
}
pflag.VisitAll(func(flag *pflag.Flag) {
klog.V(2).InfoS("FLAG", flag.Name, flag.Value)

4
pkg/tcpproxy/tcp.go
View file

@ -119,7 +119,9 @@ func (p *TCPProxy) Handle(conn net.Conn) {
func pipe(client, server net.Conn) {
doCopy := func(s, c net.Conn, cancel chan<- bool) {
io.Copy(s, c)
if _, err := io.Copy(s, c); err != nil {
klog.Errorf("Error copying data: %v", err)
}
cancel <- true
}

8
pkg/util/file/file_test.go
View file

@ -35,8 +35,12 @@ func TestSHA1(t *testing.T) {
if err != nil {
t.Fatal(err)
}
f.Write(test.content)
f.Sync()
if _, err := f.Write(test.content); err != nil {
t.Error(err)
}
if err := f.Sync(); err != nil {
t.Error(err)
}
sha := SHA1(f.Name())
f.Close()

4
pkg/util/file/file_watcher_test.go
View file

@ -59,7 +59,9 @@ func TestFileWatcher(t *testing.T) {
t.Fatalf("expected no events before writing a file")
case <-timeoutChan:
}
os.WriteFile(f.Name(), []byte{}, ReadWriteByUser)
if err := os.WriteFile(f.Name(), []byte{}, ReadWriteByUser); err != nil {
t.Errorf("unexpected error: %v", err)
}
select {
case <-events:
case <-timeoutChan:

11
pkg/util/process/sigterm_test.go
View file

@ -42,9 +42,9 @@ func (f *FakeProcess) exiterFunc(code int) {
f.exitCode = code
}
func sendDelayedSignal(delay time.Duration) {
func sendDelayedSignal(delay time.Duration) error {
time.Sleep(delay * time.Second)
syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
return syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
}
func TestHandleSigterm(t *testing.T) {
@ -66,7 +66,12 @@ func TestHandleSigterm(t *testing.T) {
for _, tt := range tests {
process := &FakeProcess{shouldError: tt.shouldError}
t.Run(tt.name, func(t *testing.T) {
go sendDelayedSignal(2) // Send a signal after 2 seconds
go func() {
err := sendDelayedSignal(2) // Send a signal after 2 seconds
if err != nil {
t.Errorf("error sending delayed signal: %v", err)
}
}()
HandleSigterm(process, tt.delay, process.exiterFunc)
})
if tt.shouldError && process.exitCode != 1 {

4
test/e2e/endpointslices/topology.go
View file

@ -76,7 +76,9 @@ var _ = framework.IngressNginxDescribeSerial("[TopologyHints] topology aware rou
status, err := f.ExecIngressPod(curlCmd)
assert.Nil(ginkgo.GinkgoT(), err)
var backends []map[string]interface{}
json.Unmarshal([]byte(status), &backends)
if err := json.Unmarshal([]byte(status), &backends); err != nil {
assert.Nil(ginkgo.GinkgoT(), err)
}
gotBackends := 0
for _, bck := range backends {
if strings.Contains(bck["name"].(string), "topology") {

4
test/e2e/security/request_smuggling.go
View file

@ -79,7 +79,9 @@ func smugglingRequest(host, addr string, port int) (string, error) {
defer conn.Close()
conn.SetDeadline(time.Now().Add(time.Second * 10))
if err := conn.SetDeadline(time.Now().Add(time.Second * 10)); err != nil {
return "", err
}
_, err = fmt.Fprintf(conn, "GET /echo HTTP/1.1\r\nHost: %v\r\nContent-Length: 56\r\n\r\nGET /_hidden/index.html HTTP/1.1\r\nHost: notlocalhost\r\n\r\n", host)
if err != nil {

25
test/e2e/settings/proxy_protocol.go
View file

@ -63,8 +63,12 @@ var _ = framework.DescribeSetting("use-proxy-protocol", func() {
defer conn.Close()
header := "PROXY TCP4 192.168.0.1 192.168.0.11 56324 1234\r\n"
conn.Write([]byte(header))
conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n"))
if _, err := conn.Write([]byte(header)); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing header")
}
if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n")); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing request")
}
data, err := io.ReadAll(conn)
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error reading connection data")
@ -96,8 +100,12 @@ var _ = framework.DescribeSetting("use-proxy-protocol", func() {
defer conn.Close()
header := "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443\r\n"
conn.Write([]byte(header))
conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n"))
if _, err := conn.Write([]byte(header)); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing header")
}
if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n")); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing request")
}
data, err := io.ReadAll(conn)
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error reading connection data")
@ -205,9 +213,12 @@ var _ = framework.DescribeSetting("use-proxy-protocol", func() {
defer conn.Close()
header := "PROXY TCP4 192.168.0.1 192.168.0.11 56324 8080\r\n"
conn.Write([]byte(header))
conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n"))
if _, err := conn.Write([]byte(header)); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing header")
}
if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: proxy-protocol\r\n\r\n")); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error writing request")
}
_, err = io.ReadAll(conn)
assert.Nil(ginkgo.GinkgoT(), err, "unexpected error reading connection data")

4
test/e2e/ssl/secret_update.go
View file

@ -73,7 +73,9 @@ var _ = framework.IngressNginxDescribe("[SSL] secret update", func() {
dummySecret.Data["some-key"] = []byte("some value")
f.KubeClientSet.CoreV1().Secrets(f.Namespace).Update(context.TODO(), dummySecret, metav1.UpdateOptions{})
if _, err := f.KubeClientSet.CoreV1().Secrets(f.Namespace).Update(context.TODO(), dummySecret, metav1.UpdateOptions{}); err != nil {
assert.Nil(ginkgo.GinkgoT(), err, "updating secret")
}
assert.NotContains(ginkgo.GinkgoT(), log, fmt.Sprintf("starting syncing of secret %v/dummy", f.Namespace))
assert.NotContains(ginkgo.GinkgoT(), log, fmt.Sprintf("error obtaining PEM from secret %v/dummy", f.Namespace))