package main
 
 import (

 	"bufio"

 	"bytes"
 	"context"

 	"io"

 	"net"

 	"net/http"

 	"strings"

 	"testing"

 	"time"

 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/stdcopy"

 	"github.com/docker/docker/testutil/request"

 	"github.com/docker/go-connections/sockets"

 	"github.com/pkg/errors"

 	"golang.org/x/net/websocket"

 	"gotest.tools/v3/assert"
 	is "gotest.tools/v3/assert/cmp"

 )
 

 func (s *DockerSuite) TestGetContainersAttachWebsocket(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	out, _ := dockerCmd(c, "run", "-dit", "busybox", "cat")

 	rwc, err := request.SockConn(10*time.Second, request.DaemonHost())

 	assert.NilError(c, err)

 	cleanedContainerID := strings.TrimSpace(out)

 	config, err := websocket.NewConfig(
 		"/containers/"+cleanedContainerID+"/attach/ws?stream=1&stdin=1&stdout=1&stderr=1",
 		"http://localhost",
 	)

 	assert.NilError(c, err)

 
 	ws, err := websocket.NewClient(config, rwc)

 	assert.NilError(c, err)

 	defer ws.Close()
 
 	expected := []byte("hello")
 	actual := make([]byte, len(expected))

 	outChan := make(chan error, 1)

 	go func() {

 		_, err := io.ReadFull(ws, actual)

 		outChan <- err
 		close(outChan)

 	}()
 

 	inChan := make(chan error, 1)

 	go func() {

 		_, err := ws.Write(expected)
 		inChan <- err
 		close(inChan)
 	}()
 
 	select {
 	case err := <-inChan:

 		assert.NilError(c, err)

 	case <-time.After(5 * time.Second):
 		c.Fatal("Timeout writing to ws")
 	}

 	select {
 	case err := <-outChan:

 		assert.NilError(c, err)

 	case <-time.After(5 * time.Second):
 		c.Fatal("Timeout reading from ws")
 	}

 	assert.Assert(c, is.DeepEqual(actual, expected), "Websocket didn't return the expected data")

 }

 
 // regression gh14320

 func (s *DockerSuite) TestPostContainersAttachContainerNotFound(c *testing.T) {

 	resp, _, err := request.Post("/containers/doesnotexist/attach")

 	assert.NilError(c, err)

 	// connection will shutdown, err should be "persistent connection closed"

 	assert.Equal(c, resp.StatusCode, http.StatusNotFound)

 	content, err := request.ReadBody(resp.Body)

 	assert.NilError(c, err)

 	expected := "No such container: doesnotexist\r\n"

 	assert.Equal(c, string(content), expected)

 }
 

 func (s *DockerSuite) TestGetContainersWsAttachContainerNotFound(c *testing.T) {

 	res, body, err := request.Get("/containers/doesnotexist/attach/ws")

 	assert.Equal(c, res.StatusCode, http.StatusNotFound)
 	assert.NilError(c, err)

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

 	expected := "No such container: doesnotexist"

 	assert.Assert(c, strings.Contains(getErrorMessage(c, b), expected))

 }

 func (s *DockerSuite) TestPostContainersAttach(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	expectSuccess := func(wc io.WriteCloser, br *bufio.Reader, stream string, tty bool) {
 		defer wc.Close()

 		expected := []byte("success")

 		_, err := wc.Write(expected)

 		assert.NilError(c, err)

 		lenHeader := 0
 		if !tty {
 			lenHeader = 8
 		}
 		actual := make([]byte, len(expected)+lenHeader)

 		_, err = readTimeout(br, actual, time.Second)

 		assert.NilError(c, err)

 		if !tty {
 			fdMap := map[string]byte{
 				"stdin":  0,
 				"stdout": 1,
 				"stderr": 2,
 			}

 			assert.Equal(c, actual[0], fdMap[stream])

 		}

 		assert.Assert(c, is.DeepEqual(actual[lenHeader:], expected), "Attach didn't return the expected data from %s", stream)

 	}
 

 	expectTimeout := func(wc io.WriteCloser, br *bufio.Reader, stream string) {
 		defer wc.Close()
 		_, err := wc.Write([]byte{'t'})

 		assert.NilError(c, err)

 		actual := make([]byte, 1)

 		_, err = readTimeout(br, actual, time.Second)
 		assert.Assert(c, err.Error() == "Timeout", "Read from %s is expected to timeout", stream)

 	}
 

 	// Create a container that only emits stdout.
 	cid, _ := dockerCmd(c, "run", "-di", "busybox", "cat")
 	cid = strings.TrimSpace(cid)

 	// Attach to the container's stdout stream.

 	wc, br, err := requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	// Check if the data from stdout can be received.

 	expectSuccess(wc, br, "stdout", false)
 

 	// Attach to the container's stderr stream.

 	wc, br, err = requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	// Since the container only emits stdout, attaching to stderr should return nothing.

 	expectTimeout(wc, br, "stdout")

 	// Test the similar functions of the stderr stream.

 	cid, _ = dockerCmd(c, "run", "-di", "busybox", "/bin/sh", "-c", "cat >&2")
 	cid = strings.TrimSpace(cid)

 	wc, br, err = requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	expectSuccess(wc, br, "stderr", false)
 	wc, br, err = requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	expectTimeout(wc, br, "stderr")

 	// Test with tty.
 	cid, _ = dockerCmd(c, "run", "-dit", "busybox", "/bin/sh", "-c", "cat >&2")
 	cid = strings.TrimSpace(cid)
 	// Attach to stdout only.

 	wc, br, err = requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stdout=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	expectSuccess(wc, br, "stdout", true)

 	// Attach without stdout stream.

 	wc, br, err = requestHijack(http.MethodPost, "/containers/"+cid+"/attach?stream=1&stdin=1&stderr=1", nil, "text/plain", request.DaemonHost())

 	assert.NilError(c, err)

 	// Nothing should be received because both the stdout and stderr of the container will be
 	// sent to the client as stdout when tty is enabled.

 	expectTimeout(wc, br, "stdout")

 
 	// Test the client API

 	client, err := client.NewClientWithOpts(client.FromEnv)

 	assert.NilError(c, err)

 	defer client.Close()

 
 	cid, _ = dockerCmd(c, "run", "-di", "busybox", "/bin/sh", "-c", "echo hello; cat")
 	cid = strings.TrimSpace(cid)
 

 	// Make sure we don't see "hello" if Logs is false

 	attachOpts := types.ContainerAttachOptions{
 		Stream: true,
 		Stdin:  true,
 		Stdout: true,

 		Stderr: true,
 		Logs:   false,

 	}
 
 	resp, err := client.ContainerAttach(context.Background(), cid, attachOpts)

 	assert.NilError(c, err)

 	expectSuccess(resp.Conn, resp.Reader, "stdout", false)
 
 	// Make sure we do see "hello" if Logs is true
 	attachOpts.Logs = true
 	resp, err = client.ContainerAttach(context.Background(), cid, attachOpts)

 	assert.NilError(c, err)

 
 	defer resp.Conn.Close()
 	resp.Conn.SetReadDeadline(time.Now().Add(time.Second))
 
 	_, err = resp.Conn.Write([]byte("success"))

 	assert.NilError(c, err)

 	var outBuf, errBuf bytes.Buffer

 	var nErr net.Error

 	_, err = stdcopy.StdCopy(&outBuf, &errBuf, resp.Reader)

 	if errors.As(err, &nErr) && nErr.Timeout() {

 		// ignore the timeout error as it is expected
 		err = nil
 	}

 	assert.NilError(c, err)
 	assert.Equal(c, errBuf.String(), "")
 	assert.Equal(c, outBuf.String(), "hello\nsuccess")

 }

 // requestHijack create a http requst to specified host with `Upgrade` header (with method
 // , contenttype, …), if receive a successful "101 Switching Protocols" response return
 // a `io.WriteCloser` and `bufio.Reader`
 func requestHijack(method, endpoint string, data io.Reader, ct, daemon string, modifiers ...func(*http.Request)) (io.WriteCloser, *bufio.Reader, error) {

 	hostURL, err := client.ParseHostURL(daemon)

 	if err != nil {

 		return nil, nil, errors.Wrap(err, "parse daemon host error")

 	}
 
 	req, err := http.NewRequest(method, endpoint, data)
 	if err != nil {

 		return nil, nil, errors.Wrap(err, "could not create new request")

 	}

 	req.URL.Scheme = "http"
 	req.URL.Host = hostURL.Host

 
 	for _, opt := range modifiers {
 		opt(req)
 	}
 
 	if ct != "" {
 		req.Header.Set("Content-Type", ct)
 	}

 
 	// must have Upgrade header
 	// server api return 101 Switching Protocols
 	req.Header.Set("Upgrade", "tcp")
 
 	// new client
 	// FIXME use testutil/request newHTTPClient
 	transport := &http.Transport{}
 	err = sockets.ConfigureTransport(transport, hostURL.Scheme, hostURL.Host)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "configure Transport error")
 	}
 
 	client := http.Client{
 		Transport: transport,
 	}
 
 	resp, err := client.Do(req)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "client.Do")
 	}
 
 	if !bodyIsWritable(resp) {
 		return nil, nil, errors.New("response.Body not writable")
 	}
 
 	return resp.Body.(io.WriteCloser), bufio.NewReader(resp.Body), nil
 }
 
 // bodyIsWritable check Response.Body is writable
 func bodyIsWritable(r *http.Response) bool {
 	_, ok := r.Body.(io.Writer)
 	return ok
 }
 
 // readTimeout read from io.Reader with timeout
 func readTimeout(r io.Reader, buf []byte, timeout time.Duration) (n int, err error) {

 	ch := make(chan bool, 1)

 	go func() {
 		n, err = io.ReadFull(r, buf)
 		ch <- true
 	}()
 	select {
 	case <-ch:
 		return
 	case <-time.After(timeout):
 		return 0, errors.New("Timeout")
 	}

 }