Source file src/net/sendfile_test.go

Documentation: net

		 1  // Copyright 2016 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  //go:build !js
		 6  // +build !js
		 7  
		 8  package net
		 9  
		10  import (
		11  	"bytes"
		12  	"crypto/sha256"
		13  	"encoding/hex"
		14  	"errors"
		15  	"fmt"
		16  	"io"
		17  	"os"
		18  	"runtime"
		19  	"sync"
		20  	"testing"
		21  	"time"
		22  )
		23  
		24  const (
		25  	newton			 = "../testdata/Isaac.Newton-Opticks.txt"
		26  	newtonLen		= 567198
		27  	newtonSHA256 = "d4a9ac22462b35e7821a4f2706c211093da678620a8f9997989ee7cf8d507bbd"
		28  )
		29  
		30  func TestSendfile(t *testing.T) {
		31  	ln, err := newLocalListener("tcp")
		32  	if err != nil {
		33  		t.Fatal(err)
		34  	}
		35  	defer ln.Close()
		36  
		37  	errc := make(chan error, 1)
		38  	go func(ln Listener) {
		39  		// Wait for a connection.
		40  		conn, err := ln.Accept()
		41  		if err != nil {
		42  			errc <- err
		43  			close(errc)
		44  			return
		45  		}
		46  
		47  		go func() {
		48  			defer close(errc)
		49  			defer conn.Close()
		50  
		51  			f, err := os.Open(newton)
		52  			if err != nil {
		53  				errc <- err
		54  				return
		55  			}
		56  			defer f.Close()
		57  
		58  			// Return file data using io.Copy, which should use
		59  			// sendFile if available.
		60  			sbytes, err := io.Copy(conn, f)
		61  			if err != nil {
		62  				errc <- err
		63  				return
		64  			}
		65  
		66  			if sbytes != newtonLen {
		67  				errc <- fmt.Errorf("sent %d bytes; expected %d", sbytes, newtonLen)
		68  				return
		69  			}
		70  		}()
		71  	}(ln)
		72  
		73  	// Connect to listener to retrieve file and verify digest matches
		74  	// expected.
		75  	c, err := Dial("tcp", ln.Addr().String())
		76  	if err != nil {
		77  		t.Fatal(err)
		78  	}
		79  	defer c.Close()
		80  
		81  	h := sha256.New()
		82  	rbytes, err := io.Copy(h, c)
		83  	if err != nil {
		84  		t.Error(err)
		85  	}
		86  
		87  	if rbytes != newtonLen {
		88  		t.Errorf("received %d bytes; expected %d", rbytes, newtonLen)
		89  	}
		90  
		91  	if res := hex.EncodeToString(h.Sum(nil)); res != newtonSHA256 {
		92  		t.Error("retrieved data hash did not match")
		93  	}
		94  
		95  	for err := range errc {
		96  		t.Error(err)
		97  	}
		98  }
		99  
	 100  func TestSendfileParts(t *testing.T) {
	 101  	ln, err := newLocalListener("tcp")
	 102  	if err != nil {
	 103  		t.Fatal(err)
	 104  	}
	 105  	defer ln.Close()
	 106  
	 107  	errc := make(chan error, 1)
	 108  	go func(ln Listener) {
	 109  		// Wait for a connection.
	 110  		conn, err := ln.Accept()
	 111  		if err != nil {
	 112  			errc <- err
	 113  			close(errc)
	 114  			return
	 115  		}
	 116  
	 117  		go func() {
	 118  			defer close(errc)
	 119  			defer conn.Close()
	 120  
	 121  			f, err := os.Open(newton)
	 122  			if err != nil {
	 123  				errc <- err
	 124  				return
	 125  			}
	 126  			defer f.Close()
	 127  
	 128  			for i := 0; i < 3; i++ {
	 129  				// Return file data using io.CopyN, which should use
	 130  				// sendFile if available.
	 131  				_, err = io.CopyN(conn, f, 3)
	 132  				if err != nil {
	 133  					errc <- err
	 134  					return
	 135  				}
	 136  			}
	 137  		}()
	 138  	}(ln)
	 139  
	 140  	c, err := Dial("tcp", ln.Addr().String())
	 141  	if err != nil {
	 142  		t.Fatal(err)
	 143  	}
	 144  	defer c.Close()
	 145  
	 146  	buf := new(bytes.Buffer)
	 147  	buf.ReadFrom(c)
	 148  
	 149  	if want, have := "Produced ", buf.String(); have != want {
	 150  		t.Errorf("unexpected server reply %q, want %q", have, want)
	 151  	}
	 152  
	 153  	for err := range errc {
	 154  		t.Error(err)
	 155  	}
	 156  }
	 157  
	 158  func TestSendfileSeeked(t *testing.T) {
	 159  	ln, err := newLocalListener("tcp")
	 160  	if err != nil {
	 161  		t.Fatal(err)
	 162  	}
	 163  	defer ln.Close()
	 164  
	 165  	const seekTo = 65 << 10
	 166  	const sendSize = 10 << 10
	 167  
	 168  	errc := make(chan error, 1)
	 169  	go func(ln Listener) {
	 170  		// Wait for a connection.
	 171  		conn, err := ln.Accept()
	 172  		if err != nil {
	 173  			errc <- err
	 174  			close(errc)
	 175  			return
	 176  		}
	 177  
	 178  		go func() {
	 179  			defer close(errc)
	 180  			defer conn.Close()
	 181  
	 182  			f, err := os.Open(newton)
	 183  			if err != nil {
	 184  				errc <- err
	 185  				return
	 186  			}
	 187  			defer f.Close()
	 188  			if _, err := f.Seek(seekTo, os.SEEK_SET); err != nil {
	 189  				errc <- err
	 190  				return
	 191  			}
	 192  
	 193  			_, err = io.CopyN(conn, f, sendSize)
	 194  			if err != nil {
	 195  				errc <- err
	 196  				return
	 197  			}
	 198  		}()
	 199  	}(ln)
	 200  
	 201  	c, err := Dial("tcp", ln.Addr().String())
	 202  	if err != nil {
	 203  		t.Fatal(err)
	 204  	}
	 205  	defer c.Close()
	 206  
	 207  	buf := new(bytes.Buffer)
	 208  	buf.ReadFrom(c)
	 209  
	 210  	if buf.Len() != sendSize {
	 211  		t.Errorf("Got %d bytes; want %d", buf.Len(), sendSize)
	 212  	}
	 213  
	 214  	for err := range errc {
	 215  		t.Error(err)
	 216  	}
	 217  }
	 218  
	 219  // Test that sendfile doesn't put a pipe into blocking mode.
	 220  func TestSendfilePipe(t *testing.T) {
	 221  	switch runtime.GOOS {
	 222  	case "plan9", "windows":
	 223  		// These systems don't support deadlines on pipes.
	 224  		t.Skipf("skipping on %s", runtime.GOOS)
	 225  	}
	 226  
	 227  	t.Parallel()
	 228  
	 229  	ln, err := newLocalListener("tcp")
	 230  	if err != nil {
	 231  		t.Fatal(err)
	 232  	}
	 233  	defer ln.Close()
	 234  
	 235  	r, w, err := os.Pipe()
	 236  	if err != nil {
	 237  		t.Fatal(err)
	 238  	}
	 239  	defer w.Close()
	 240  	defer r.Close()
	 241  
	 242  	copied := make(chan bool)
	 243  
	 244  	var wg sync.WaitGroup
	 245  	wg.Add(1)
	 246  	go func() {
	 247  		// Accept a connection and copy 1 byte from the read end of
	 248  		// the pipe to the connection. This will call into sendfile.
	 249  		defer wg.Done()
	 250  		conn, err := ln.Accept()
	 251  		if err != nil {
	 252  			t.Error(err)
	 253  			return
	 254  		}
	 255  		defer conn.Close()
	 256  		_, err = io.CopyN(conn, r, 1)
	 257  		if err != nil {
	 258  			t.Error(err)
	 259  			return
	 260  		}
	 261  		// Signal the main goroutine that we've copied the byte.
	 262  		close(copied)
	 263  	}()
	 264  
	 265  	wg.Add(1)
	 266  	go func() {
	 267  		// Write 1 byte to the write end of the pipe.
	 268  		defer wg.Done()
	 269  		_, err := w.Write([]byte{'a'})
	 270  		if err != nil {
	 271  			t.Error(err)
	 272  		}
	 273  	}()
	 274  
	 275  	wg.Add(1)
	 276  	go func() {
	 277  		// Connect to the server started two goroutines up and
	 278  		// discard any data that it writes.
	 279  		defer wg.Done()
	 280  		conn, err := Dial("tcp", ln.Addr().String())
	 281  		if err != nil {
	 282  			t.Error(err)
	 283  			return
	 284  		}
	 285  		defer conn.Close()
	 286  		io.Copy(io.Discard, conn)
	 287  	}()
	 288  
	 289  	// Wait for the byte to be copied, meaning that sendfile has
	 290  	// been called on the pipe.
	 291  	<-copied
	 292  
	 293  	// Set a very short deadline on the read end of the pipe.
	 294  	if err := r.SetDeadline(time.Now().Add(time.Microsecond)); err != nil {
	 295  		t.Fatal(err)
	 296  	}
	 297  
	 298  	wg.Add(1)
	 299  	go func() {
	 300  		// Wait for much longer than the deadline and write a byte
	 301  		// to the pipe.
	 302  		defer wg.Done()
	 303  		time.Sleep(50 * time.Millisecond)
	 304  		w.Write([]byte{'b'})
	 305  	}()
	 306  
	 307  	// If this read does not time out, the pipe was incorrectly
	 308  	// put into blocking mode.
	 309  	_, err = r.Read(make([]byte, 1))
	 310  	if err == nil {
	 311  		t.Error("Read did not time out")
	 312  	} else if !os.IsTimeout(err) {
	 313  		t.Errorf("got error %v, expected a time out", err)
	 314  	}
	 315  
	 316  	wg.Wait()
	 317  }
	 318  
	 319  // Issue 43822: tests that returns EOF when conn write timeout.
	 320  func TestSendfileOnWriteTimeoutExceeded(t *testing.T) {
	 321  	ln, err := newLocalListener("tcp")
	 322  	if err != nil {
	 323  		t.Fatal(err)
	 324  	}
	 325  	defer ln.Close()
	 326  
	 327  	errc := make(chan error, 1)
	 328  	go func(ln Listener) (retErr error) {
	 329  		defer func() {
	 330  			errc <- retErr
	 331  			close(errc)
	 332  		}()
	 333  
	 334  		conn, err := ln.Accept()
	 335  		if err != nil {
	 336  			return err
	 337  		}
	 338  		defer conn.Close()
	 339  
	 340  		// Set the write deadline in the past(1h ago). It makes
	 341  		// sure that it is always write timeout.
	 342  		if err := conn.SetWriteDeadline(time.Now().Add(-1 * time.Hour)); err != nil {
	 343  			return err
	 344  		}
	 345  
	 346  		f, err := os.Open(newton)
	 347  		if err != nil {
	 348  			return err
	 349  		}
	 350  		defer f.Close()
	 351  
	 352  		_, err = io.Copy(conn, f)
	 353  		if errors.Is(err, os.ErrDeadlineExceeded) {
	 354  			return nil
	 355  		}
	 356  
	 357  		if err == nil {
	 358  			err = fmt.Errorf("expected ErrDeadlineExceeded, but got nil")
	 359  		}
	 360  		return err
	 361  	}(ln)
	 362  
	 363  	conn, err := Dial("tcp", ln.Addr().String())
	 364  	if err != nil {
	 365  		t.Fatal(err)
	 366  	}
	 367  	defer conn.Close()
	 368  
	 369  	n, err := io.Copy(io.Discard, conn)
	 370  	if err != nil {
	 371  		t.Fatalf("expected nil error, but got %v", err)
	 372  	}
	 373  	if n != 0 {
	 374  		t.Fatalf("expected receive zero, but got %d byte(s)", n)
	 375  	}
	 376  
	 377  	if err := <-errc; err != nil {
	 378  		t.Fatal(err)
	 379  	}
	 380  }
	 381  

View as plain text