Go: Programação Distribuída

De Aulas

TCP Cliente

Efetua uma conexão TCP com um servidor. Aguarda o usuário digitar mensagens e dar ENTER. Para saír, basta digitar EXIT. 

 1package main
 2
 3import (
 4	"bufio"
 5	"fmt"
 6	"net"
 7	"os"
 8	"strings"
 9)
10
11func main() {
12	arguments := os.Args     // Pega os argumentos da linha de comando
13	if len(arguments) == 1 { // Se não tiver argumentos retorna erro
14		fmt.Println("Enter with arguments host:port.")
15		return
16	}
17
18	// Usa os argumentos e se conecta ao servidor host:port
19	c, err := net.Dial("tcp", arguments[1])
20	if err != nil {
21		fmt.Println(err)
22		return
23	}
24	defer c.Close()
25	fmt.Print("Digit your message and press key ENTER to send.")
26	fmt.Println("To exit, digit EXIT and press key exit.")
27	for {
28		reader := bufio.NewReader(os.Stdin) // Prepara o buffer de leitura
29		fmt.Print("MSG: ")
30		text, _ := reader.ReadString('\n') // Le um texto do teclado
31		fmt.Fprintf(c, text+"\n")          // Envia o texto pela conexão
32
33		message, _ := bufio.NewReader(c).ReadString('\n') // Aguarda resposta do servidor
34		fmt.Print("RCV: " + message)
35		// Se a resposta for EXIT, fecha a conexão e o cliente
36		if strings.ToUpper(strings.TrimSpace(string(text))) == "EXIT" {
37			fmt.Println("TCP client exiting...")
38			return
39		}
40	}
41}

TCP Servidor Simples

Inicia o servidor e fica aguardando um cliente. Recebe as mensagens do cliente. Quando o cliente envia EXIT, fecha o servidor e a conexão. 

 1package main
 2
 3import (
 4	"bufio"
 5	"fmt"
 6	"net"
 7	"os"
 8	"strings"
 9	"time"
10)
11
12func main() {
13	arguments := os.Args     // Pega a porta como argumento da linha de comando
14	if len(arguments) == 1 { // Se não for passado a porta dá erro
15		fmt.Println("Enter with port number in argument")
16		return
17	}
18	l, err := net.Listen("tcp", ":"+arguments[1]) // Inicia a conexão TCP na porta
19	if err != nil {
20		fmt.Println(err)
21		return
22	}
23	defer l.Close() // Ao final, fecha a conexão.
24	fmt.Println("TCP Server initialized at port", arguments[1])
25
26	c, err := l.Accept() // Fica aguardando um cliente se conectar
27	if err != nil {
28		fmt.Println(err)
29		return
30	}
31	fmt.Println("Client connected...")
32
33	for { // Laço eterno
34		// Recebe informações no buffer de leitura
35		netData, err := bufio.NewReader(c).ReadString('\n')
36		if err != nil {
37			fmt.Println(err)
38			return
39		}
40		// Se for EXT, fecha o sevidor, mas fecha a conexão antes
41		if strings.ToUpper(strings.TrimSpace(string(netData))) == "EXIT" {
42			fmt.Println("TCP Server terminated...")
43			return
44		}
45
46		// Mostra a mensagem na tela e envia de volta o horário
47		fmt.Print(": ", string(netData))
48		t := time.Now()
49		myTime := t.Format(time.RFC3339) + "\n"
50		c.Write([]byte(myTime)) // Escreve no buffer de escrita para o cliente
51	}
52}

TCP Servidor com múltiplas conexões

Observe que agora temos um servidor diferente. No laço for do main ficamos aguardando um cliente se conectar. Quando houver uma conexão, essa conexão é transferida para uma função child que é chamada concorrentemente como gorotine e continua o laço, aguardando uma nova conexão.

Cada gorotine, ora chamada child, vai ficar responsável por gerenciar uma conexão específica. Quando o cliente mandar a palavra exit, não fecha o servidor, apenas aquela conexão.

Dessa forma, nosso servidor pode trabalhar com múltiplas conexões simultâneas, respondendo concorrentemente há vários clientes.

Veja que no código, quando um cliente manda uma mensagem, escrevemos qual o endereço da conexão para identificar a mensagem e diferenciá-la das mensagens dos outros clientes. 

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
	"time"
)

func child(conn net.Conn) {
	addr := conn.RemoteAddr() // Pega o endereço do cliente
	fmt.Println(addr, ": connected...")
	defer fmt.Println(addr, ": disconnected...")
	defer conn.Close() // Ao final, fecha a conexão

	for {
		// Recebe informações no buffer de leitura
		netData, err := bufio.NewReader(conn).ReadString('\n')
		if err != nil {
			fmt.Println(err)
			return
		}
		// Se for EXIT, fecha fecha a conexão
		if strings.ToUpper(strings.TrimSpace(string(netData))) == "EXIT" {
			fmt.Println(addr, ": exit...")
			return
		}
		// Mostra a mensagem na tela e envia de volta o horário
		fmt.Print(addr, " : ", string(netData))
		t := time.Now()
		myTime := t.Format(time.RFC3339) + "\n"
		conn.Write([]byte(myTime)) // Escreve no buffer de escrita para o cliente
	}
}

func main() {
	arguments := os.Args     // Pega a porta como argumento da linha de comando
	if len(arguments) == 1 { // Se não for passado a porta dá erro
		fmt.Println("Enter with port number in argument")
		return
	}
	l, err := net.Listen("tcp", ":"+arguments[1]) // Configura uma porta TCP
	if err != nil {
		fmt.Println(err)
		return
	}
	defer l.Close() // Ao final, fecha a conexão.
	fmt.Println("TCP Server initialized at port", arguments[1])

	for {
		c, err := l.Accept() // Aguarda o próximo cliente se conectar
		if err != nil {
			fmt.Println(err)
			return
		}
		go child(c) // Passa a conexão para uma gorotine gerenciar
	}
}

Daria pra fazer um chat de grupo com isso, não? É um bom exercício.

UDP Cliente

Veja que a conexão com um servidor UPD é diferente, então o cliente UDP também precisa ser específico pra isso. Por isso, não tente usar um cliente TCP para se conectar a um servidor UDP, ou melhor, tente pra ver o que acontece (¬‿¬)

Veja que aqui temos uma troca de mensagens via buffer de bytes. 

 1package main
 2
 3import (
 4	"bufio"
 5	"fmt"
 6	"net"
 7	"os"
 8	"strings"
 9)
10
11func main() {
12	arguments := os.Args
13	if len(arguments) == 1 {
14		fmt.Println("Please provide a host:port string")
15		return
16	}
17	CONNECT := arguments[1]
18
19	s, err := net.ResolveUDPAddr("udp4", CONNECT)
20	c, err := net.DialUDP("udp4", nil, s)
21	if err != nil {
22		fmt.Println(err)
23		return
24	}
25
26	fmt.Printf("The UDP server is %s\n", c.RemoteAddr().String())
27	defer c.Close()
28
29	for {
30		reader := bufio.NewReader(os.Stdin)
31		fmt.Print(">> ")
32		text, _ := reader.ReadString('\n')
33		data := []byte(text + "\n")
34		_, err = c.Write(data)
35		if strings.ToUpper(strings.TrimSpace(string(data))) == "EXIT" {
36			fmt.Println("Exiting UDP client!")
37			return
38		}
39
40		if err != nil {
41			fmt.Println(err)
42			return
43		}
44
45		buffer := make([]byte, 1024)
46		n, _, err := c.ReadFromUDP(buffer)
47		if err != nil {
48			fmt.Println(err)
49			return
50		}
51		fmt.Printf("Reply: %s\n", string(buffer[0:n]))
52	}
53}

UDP Servidor

E então, nosso servidor UDP. É muito parecido com o TCP, mas configurado de forma diferente e agora trabalha com mensagens na forma de buffer de bytes. 

 1package main
 2
 3import (
 4	"fmt"
 5	"math/rand"
 6	"net"
 7	"os"
 8	"strconv"
 9	"strings"
10	"time"
11)
12
13func random(min, max int) int {
14	return rand.Intn(max-min) + min
15}
16
17func main() {
18	arguments := os.Args
19	if len(arguments) == 1 {
20		fmt.Println("Please provide a port number!")
21		return
22	}
23	PORT := ":" + arguments[1]
24
25	s, err := net.ResolveUDPAddr("udp4", PORT)
26	if err != nil {
27		fmt.Println(err)
28		return
29	}
30
31	connection, err := net.ListenUDP("udp4", s)
32	if err != nil {
33		fmt.Println(err)
34		return
35	}
36
37	defer connection.Close()
38	buffer := make([]byte, 1024)
39	rand.Seed(time.Now().Unix())
40
41	for {
42		/*
43			Veja que estamos trabalhando com leitura em buffer, em bytes.
44			A função ReadFromUDP retorna também o tamanho da mensagem que
45			estamos recebendo no buffer e transformamos em string
46		*/
47		n, addr, err := connection.ReadFromUDP(buffer)
48		fmt.Print(addr, " -> ", string(buffer[0:n-1]))
49
50		// Se a mensagem for exit, fechamos a conexão e o servidor
51		if strings.ToUpper(strings.TrimSpace(string(buffer[0:n]))) == "EXIT" {
52			fmt.Println("Exiting UDP server!")
53			return
54		}
55
56		data := []byte(strconv.Itoa(rand.Intn(1000)))
57		fmt.Println(addr, "<-", string(data))
58		_, err = connection.WriteToUDP(data, addr)
59		if err != nil {
60			fmt.Println(err)
61			return
62		}
63	}
64}
Disponível em “https://saulo.arisa.com.br/wiki/index.php?title=Go:_Programação_Distribuída&oldid=7790”