Go: Programação Distribuída

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.

package main

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

func main() {
	arguments := os.Args     // Pega os argumentos da linha de comando
	if len(arguments) == 1 { // Se não tiver argumentos retorna erro
		fmt.Println("Enter with arguments host:port.")
		return
	}

	// Usa os argumentos e se conecta ao servidor host:port
	c, err := net.Dial("tcp", arguments[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	defer c.Close()
	fmt.Print("Digit your message and press key ENTER to send.")
	fmt.Println("To exit, digit EXIT and press key emter.")
	for {
		reader := bufio.NewReader(os.Stdin) // Prepara o buffer de leitura
		fmt.Print("MSG: ")
		text, _ := reader.ReadString('\n') // Le um texto do teclado
		fmt.Fprintf(c, text+"\n")          // Envia o texto pela conexão

		message, _ := bufio.NewReader(c).ReadString('\n') // Aguarda resposta do servidor
		fmt.Print("RCV: " + message)
		// Se a resposta for EXIT, fecha a conexão e o cliente
		if strings.ToUpper(strings.TrimSpace(string(text))) == "EXIT" {
			fmt.Println("TCP client exiting...")
			return
		}
	}
}

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.

package main

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

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]) // Inicia a conexão TCP na porta
	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])

	c, err := l.Accept() // Fica aguardando um cliente se conectar
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Client connected...")

	for { // Laço eterno
		// Recebe informações no buffer de leitura
		netData, err := bufio.NewReader(c).ReadString('\n')
		if err != nil {
			fmt.Println(err)
			return
		}
		// Se for EXIT, fecha o sevidor, mas fecha a conexão antes
		if strings.ToUpper(strings.TrimSpace(string(netData))) == "EXIT" {
			fmt.Println("TCP Server terminated...")
			return
		}

		// Mostra a mensagem na tela e envia de volta o horário
		fmt.Print(": ", string(netData))
		t := time.Now()
		myTime := t.Format(time.RFC3339) + "\n"
		c.Write([]byte(myTime)) // Escreve no buffer de escrita para o cliente
	}
}

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.

package main

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

func main() {
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Please provide a host:port string")
		return
	}

	s, err := net.ResolveUDPAddr("udp4", arguments[1])
	c, err := net.DialUDP("udp4", nil, s)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("The UDP server is", c.RemoteAddr().String())
	defer c.Close()

	for {
		reader := bufio.NewReader(os.Stdin)
		fmt.Print(">> ")
		text, _ := reader.ReadString('\n')
		data := []byte(text + "\n")
		_, err = c.Write(data)
		if strings.ToUpper(strings.TrimSpace(string(data))) == "EXIT" {
			fmt.Println("Exiting UDP client!")
			return
		}
		if err != nil {
			fmt.Println(err)
			return
		}
		buffer := make([]byte, 1024)
		n, _, err := c.ReadFromUDP(buffer)
		if err != nil {
			fmt.Println(err)
			return
		}
		fmt.Println("Reply:", string(buffer[0:n]))
	}
}

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.

package main

import (
	"fmt"
	"math/rand"
	"net"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Please provide a port number!")
		return
	}
	s, err := net.ResolveUDPAddr("udp4", ":"+arguments[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	conn, err := net.ListenUDP("udp4", s)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	buffer := make([]byte, 1024)
	rand.Seed(time.Now().Unix())

	for {
		/*
			Veja que estamos trabalhando com leitura em buffer, em bytes.
			A função ReadFromUDP retorna também o tamanho da mensagem que
			estamos recebendo no buffer e transformamos em string
		*/
		n, addr, err := conn.ReadFromUDP(buffer)
		fmt.Print(addr, " -> ", string(buffer[0:n-1]))

		// Se a mensagem for exit, fechamos a conexão e o servidor
		if strings.ToUpper(strings.TrimSpace(string(buffer[0:n]))) == "EXIT" {
			fmt.Println("Exiting UDP server!")
			return
		}

		data := []byte(strconv.Itoa(rand.Intn(1000)))
		fmt.Println(addr, "<-", string(data))
		_, err = conn.WriteToUDP(data, addr)
		if err != nil {
			fmt.Println(err)
			return
		}
	}
}

Exemplo de Computação Distribuída

Vamos usar como exemplo um programa que calcula o fatorial de um número, ou seja:

n! = 1 * 2 * 3 * ... * n

Contudo, vamos dividir o problema em partes e mandar para servidores executar esses pedaços de cálculos para por fim calcular o resultado final no programa principal.

Vamos supor que temos o número 15 e queremos dividir em 4 subprocessos. Também temos 3 servidores disponíveis para executar o cálculo. Veja que um dos servidores vai receber dois pacotes para calcular.

Para isso, dividimos os números em 4 blocos

• de 1 a 4
• de 5 a 8
• de 9 a 12
• de 13 a 15 (lembrando que não podemos passar do valor que queremos calcular)

No programa, vamos enviando cada um pacote de dados (begin, end) para cada servidor. Quando acabarem os servidores disponíveis, começa novamente do primeiro e vai enviando novos pacotes de dados. Nesse caso, só mandou dois pacotes para o primeiro.

Conforme as gorotines vão recebendo o resultado, vão jogando em um canal buffer.

Quando todas as rotinas terminam, o programa pega todos os resultados e multiplicas eles, gerando o resultado final.

Do lado do servidor, ele apenas multiplica cada número, do número inicial até o final, e envia de volta o resultado.

Veja que estamos trabalhando com mensagens JSON aqui.

Servidor

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net"
	"os"
	"strconv"
)

type Message struct {
	Begin int `json:"begin"`
	End   int `json:"end"`
}

func child(conn net.Conn) {
	defer conn.Close()
	netData, err := bufio.NewReader(conn).ReadString('\n')
	if err != nil {
		fmt.Println(err)
		return
	}
	msg := Message{}
	json.Unmarshal([]byte(netData), &msg)
	out := 1
	for i := msg.Begin; i <= msg.End; i++ {
		out *= i
	}
	fmt.Println(msg.Begin, "->", msg.End, ":", out)
	conn.Write([]byte(strconv.Itoa(out)))
}

func main() {
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Enter with port number in argument")
		return
	}
	l, err := net.Listen("tcp", ":"+arguments[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	defer l.Close()
	fmt.Println("TCP Server initialized at port", arguments[1])

	for {
		c, err := l.Accept()
		if err != nil {
			fmt.Println(err)
			return
		}
		go child(c)
	}
}

Cliente

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net"
	"os"
	"strconv"
	"sync"
)

type Message struct { // Estrutura da mensagem
	Begin int `json:"begin"`
	End   int `json:"end"`
}

func connect_server(wg *sync.WaitGroup, ch chan int, server string, begin, end int) {
	defer wg.Done()
	c, err := net.Dial("tcp", server) // Conecta ao servidor
	if err != nil {
		fmt.Println(err)
		return
	}
	defer c.Close()
	msg := Message{begin, end}                        // cria uma mensagem na estrutura definida
	msgJson, _ := json.Marshal(msg)                   // transforma em string json
	fmt.Fprintf(c, string(msgJson)+"\n")              // envia ao servidor
	message, _ := bufio.NewReader(c).ReadString('\n') // aguarda a resposta
	result, err := strconv.Atoi(message)              // transforma a resposta para inteiro
	if err == nil {
		fmt.Println(begin, "->", end, ":", result)
		ch <- result // manda o resultado para o programa principal
	}
}

/*
	EXECUÇÃO:
	go run fat_dist_cli.go [value] [rotines] [server:port] ...

	1: Valor para calcular o fatorial
	2: Quantidade de gorotines, ou conexões a servidores
	3 em diante: servidores para se conectar no formato servidor:porta

	EXEMPLO:

	go run fat_dist_cli.go 20 5 localhost:4400 localhost:4402 localhost:4401

	O exemplo acima pede para calcular o fatorial de 20, dividindo em 5
	subrotinas. Em sequência temos 3 servidores para utilizar. Como o número
	de servidores é menor do que a quantidade de subrotinas, dois deles vão receber
	duas requisições de cálculos
*/

func main() {
	args := os.Args                        // pega os argumentos
	value, _ := strconv.Atoi(args[1])      // pega o valor
	rotines, _ := strconv.Atoi(args[2])    // pega a quantidade de rotinas
	size := int(value / rotines)           // calcula o tamanho do bloco a separar
	servers := make([]string, len(args)-3) // cria o vetor de servidores
	for i := 3; i < len(args); i++ {       // coloca os parâmetros como servidores
		servers[i-3] = args[i]
	}

	var wg sync.WaitGroup
	wg.Add(rotines)
	ch := make(chan int, rotines)

	j := 0
	end := 0
	for i := 0; i < rotines; i++ { // cria as subrotinas
		begin := end + 1   // separa o inicio
		end = begin + size // e o fim do bloco de cálculo
		if end > value {   // Não pode passar do valor total
			end = value
		}
		go connect_server(&wg, ch, servers[j], begin, end) // envia para um servidor
		j++
		if j >= len(servers) {
			j = 0
		}
	}
	wg.Wait() // aguarda os servidores terminarem
	close(ch)
	// Pega os resultados e multiplica-os
	result := 1
	for v := range ch {
		result *= v
	}
	// apresenta o resultado final
	fmt.Println("Fatorial de", value, "é", result)
}

Atividades

Agora que já revisitamos conceitos sobre processo, comunicação entre processos, programação concorrente e distribuída, podemos trabalhar em um desafio mais complexo e divertido.

Vamos desenvolver uma aplicação distribuída envolvendo cliente e servidores. Nesse caso podemos imaginar uma aplicação que roda em um computador cliente e, para que sua execução seja mais rápida, distribuímos o processamento em servidores que estão em outros computadores.

Descrição

• Essa atividade pode ser feita em grupo de até 4 pessoas ou individual;
• Deve desenvolver um servidor que executa alguma(s) operação(s);
• O servidor pode resolver problemas como:
  • operações matemáticas/cálculos
  • ordenação de strings
  • codificação e decodificação de strings
  • etc. O legal é fazer uma pesquisa de que tipo de aplicação pode ser distribuída.
• O cliente pode ser no modo texto mesmo, ou se o grupo preferir um desafio maior, pode ser feito em modo gráfico (desktop). Existem várias bibliotecas pra isso, a exemplo da biblioteca fyne.io.

Funcionamento

• O usuário requisita alguma operação no cliente;
• O programa cliente distribui o processamento e envia para n servidores;
• O servidor recebe uma mensagem string que pode ser no formato JSON, ou XML, ou pode ser usando algum formato que o grupo mesmo cria. O legal é manter em um padrão já existente;
• Os servidores respondem para o cliente com o resultado em uma mensagem string, no mesmo formato recebido (ex. JSON);
• O cliente reúne os resultados para apresentar ao cliente.
• OBS: os servidores não precisam fazer as mesmas operações. Podem ser programadas diferentes operações para resolver o problema distribuído e pode dar uma maior complexidade ao desenvolvimento, deixando a atividade mais divertida.

Nessa atividade existem três tipos de processos envolvidos:

• Processo Cliente: localizado em um computador cliente. O usuário desse processo deve chamá-lo para efetuar alguma operação. O processo cliente envia uma mensagem para o servidor (via socket) que envia de volta o resultado. O programa cliente apresenta o resultado ao usuário.
• Processo Servidor: localizado em um computador servidor. Esse processo recebe uma requisição (via socket) de um cliente e inicia um processo filho para gerenciar a conexão. Depois de tratar a requisição, retorna o resultado ao cliente.
• Processo Executor: localizado no mesmo computador que o Processo Servidor. Recebe uma mensagem via pipes/canais da operação, executa o processamento e retorna o resultado também via pipe.

Atividade e A3

Essa atividade valerá 10 pontos da A3 nessa UC. Lembrando que a A3 são 40 pontos ao total.