package main

import (
    "log"
    "net"
    "os"
    "time"
)

var (
    network = "tcp"
    address = "0.0.0.0:8080"
)
func main() {
    os.Remove(address)
    socket, err := net.Listen(network, address)
    if err != nil {
        log.Fatal(err)
    }

    for {
        connectedSocket, err := socket.Accept()
        if err != nil{
            log.Fatal(err)
        }
        go func() {
            for i := 0; i <= 10; i++{
                connectedSocket.Write([]byte("pong\n"))
                time.Sleep(time.Second)
            }
            connectedSocket.Close()
        }()
    }
}

$ netstat --tcp
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60082     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60084     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60078     ESTABLISHED

$ netstat --tcp
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60082     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60084     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60078     ESTABLISHED
tcp6       0      0 ip-172-31-34-1:http-alt 124.50.93.166:42434     ESTABLISHED

$ netstat --tcp
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60082     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60084     ESTABLISHED
tcp        0      0 ip-172-31-34-13.ap-:ssh 124.50.93.166:60078     ESTABLISHED
tcp6       0      0 ip-172-31-34-1:http-alt 124.50.93.166:42434     TIME_WAIT

$ mysql
stat /var/lib/mysql/mysql.sock
stat: cannot stat '/var/lib/mysql/mysql.sock': Permission denied

$ docker
docker: Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

# ubuntu 사용자로 unix domain socket server 프로세스를 띄운 경우
# ubuntu 사용자로는 잘 접속이 된다.
ubuntu@ec2 $ go test -v
=== RUN   TestSocket
=== RUN   TestSocket/tcp
2021/02/13 12:59:06 pong
=== RUN   TestSocket/unix
2021/02/13 12:59:06 pong
--- PASS: TestSocket (0.00s)
    --- PASS: TestSocket/tcp (0.00s)
    --- PASS: TestSocket/unix (0.00s)
PASS
ok  	uds	0.004s

# server가 생성한 unix domain socket에 write 권한이 없는
# guest1이라는 사용자로는 server와 unix domain socket으로는 통신할 수 없고,
# 앞서 오픈소스를 이용하며 겪었던 에러와 마찬가지로 권한 이슈가 발생한다.
# 하지만 TCP 소켓을 이용한 경우는 원활히 ping-pong test가 성공한 것을 볼 수 있다.
guest1@ec2 $ go test -v
=== RUN   TestSocket
=== RUN   TestSocket/tcp
2021/02/13 12:59:01 pong
=== RUN   TestSocket/unix
    main_test.go:21: 
        	Error Trace:	main_test.go:21
        	Error:      	Received unexpected error:
        	            	dial unix jinsu.sock: connect: permission denied
        	Test:       	TestSocket/unix
--- FAIL: TestSocket (0.00s)
    --- PASS: TestSocket/tcp (0.00s)
    --- FAIL: TestSocket/unix (0.00s)

# 하지만 재미있게도 guest1도 socket에 write할 수 있도록 권한을 수정해주니
# guest1도 unix domain socket으로 무리 없이 통신이 가능했다!
guest1@ec2 $ sudo chmod 777 jinsu.sock
guest1@ec2 $ go test -v
=== RUN   TestSocket
=== RUN   TestSocket/tcp
2021/02/13 12:59:06 pong
=== RUN   TestSocket/unix
2021/02/13 12:59:06 pong
--- PASS: TestSocket (0.00s)
    --- PASS: TestSocket/tcp (0.00s)
    --- PASS: TestSocket/unix (0.00s)
PASS
ok  	uds	0.004s

// main.go
// 한 프로세스 내에서 TCP Socket과 Unix Domain Socket 두 가지를 이용해
// 통신할 수 있는 프로그램
package main

import (
    "errors"
    "io"
    "log"
    "net"
    "os"
    "time"
)

func main() {
    go RunTCPSocketServer()
    go RunUnixDomainSocketServer()

    for {
        log.Println("Dummy waiting...")
        time.Sleep(time.Minute)
    }
}

func RunTCPSocketServer(){
    log.Println("Run TCPSocketServer...")
    run("tcp", "0.0.0.0:8080")
}

func RunUnixDomainSocketServer(){
    log.Println("Run UnixDomainSocketServer...")
    serverSocketName := "jinsu.sock"
    os.Remove(serverSocketName)
    run("unix", serverSocketName)
}

// TCP socket을 이용해 서버를 띄우든 Unix Domain Socket을 이용해 서버를 띄우든
// 간단히 인자 값만 변경해서 이용할 수 있다!
func run(network, address string){
    buf := make([]byte, 1024)
    socket, err := net.Listen(network, address)
    if err != nil {
        log.Fatal(err)
    }

    for {
        connectedSocket, err := socket.Accept()
        if err != nil{
            log.Fatal(err)
        }
        go func() {
            for{
                n, err := connectedSocket.Read(buf)
                if err != nil{
                    if !errors.Is(io.EOF, err){
                        log.Fatal(err)
                    } else{
                        log.Print("[Error]", err)
                        break
                    }
                }
                log.Println(network, "Client sent:", n)
                connectedSocket.Write([]byte("pong"))
            }
            connectedSocket.Close()
        }()
    }
}

// main_test.go
// tcp socket과 unix domain socket을 이용해 성공적으로 서버와 통신이
// 이루어지는지 테스트하는 테스트 코드
// tcp와 unix domain socket의 성능을 비교하는 벤치마크 코드
package main

import (
    "errors"
    "github.com/stretchr/testify/assert"
    "io"
    "log"
    "net"
    "testing"
)

func TestSocket(t *testing.T){
    args := [][]string{
        []string{"tcp", "0.0.0.0:8080"},
        []string{"unix", "jinsu.sock"},
    }

    for _, arg := range args{
        t.Run(arg[0], func(t *testing.T) {
            conn, err := net.Dial(arg[0], arg[1])
            assert.NoError(t, err)
            buf := make([]byte, 1024)
            _, err = conn.Write([]byte("ping"))
            if err != nil{
                log.Fatal(err)
            }
            n, err := conn.Read(buf)
            if err != nil{
                if ! errors.Is(io.EOF, err){
                    log.Println(err)
                }
            }
            log.Println(string(buf[:n]))
        })
    }
}

func BenchmarkSocket(b *testing.B) {
    args := [][]string{
        []string{"tcp", "0.0.0.0:8080"},
        []string{"unix", "jinsu.sock"},
    }
    for _, arg := range args{
        b.Run(arg[0], func(b *testing.B) {
            //log.Println("Out") // b.N과 상관 없이 args의 길이에 따라 출력됨.
            conn, err := net.Dial(arg[0], arg[1])
            assert.NoError(b, err)
            buf := make([]byte, 1024)
            for i := 0; i < b.N; i++{
                //log.Println("In") // b.N만큼 수행됨
                _, err := conn.Write([]byte("ping"))
                assert.NoError(b, err)
                _, err = conn.Read(buf)
                if err != nil{
                    if !errors.Is(io.EOF, err){
                        b.Fail()
                    }
                }
            }
        })
    }
}

$ go test -bench=. -benchtime=100000x
goos: linux
goarch: amd64
pkg: uds
BenchmarkSocket/tcp         	  100000	    104537 ns/op
BenchmarkSocket/unix        	  100000	     83456 ns/op
PASS
ok  	uds	18.808s