Blog

A linguagem Go, conhecida por sua simplicidade e eficiência, oferece uma biblioteca padrão extensa e robusta, projetada para facilitar uma ampla gama de tarefas de programação. Enquanto a documentação oficial da linguagem se destaca por sua clareza e abrangência, este texto busca complementar esses recursos, focando em uma seleção cuidadosa de pacotes que são fundamentais para a construção de aplicativos simples, mas eficazes.

A abordagem aqui não é uma reescrita exaustiva da documentação, mas sim um mergulho direcionado nos aspectos práticos e aplicados dos pacotes que formam o núcleo da biblioteca padrão do Go. Ao focar em 2 ou 3 pacotes essenciais inicialmente, pretendemos fornecer uma base sólida que servirá como ponto de partida para explorar as capacidades da linguagem de forma mais profunda e detalhada.

Além disso, é importante frisar que esta exploração é apenas o começo de uma jornada mais ampla. No futuro, pretendemos expandir nosso escopo para incluir pacotes mais especializados e avançados, abrindo novos horizontes e possibilidades para os desenvolvedores que buscam soluções mais complexas e refinadas.

Portanto, seja você um novato buscando entender os fundamentos ou um desenvolvedor experiente procurando aprimorar seus conhecimentos, este texto é projetado para ser um recurso valioso, proporcionando uma compreensão prática e aplicada da biblioteca padrão do Go e preparando o terreno para explorações futuras em tópicos mais avançados.

Pacote os

Na última vez que consultei o pacote os, ele continha mais de 150 entradas, incluindo funções, tipos, interfaces, constantes, entre outros. Este pacote é crucial para a interação com o sistema operacional, fornecendo funcionalidades essenciais para a leitura e escrita de arquivos, acesso à estrutura de diretórios, execução de comandos, entre outros. Aqui, tentarei categorizar essas funcionalidades em alguns tópicos principais.

Para uma compreensão mais profunda, recomenda-se consultar a documentação oficial do pacote os.

Acessando Informações do Sistema

Neste primeiro segmento, vou reunir funções do pacote os que retornam informações do sistema local. Essencialmente, explorarei algumas funções da série os.Get… A maioria desses comandos retornam informações compatíveis com sistemas Unix-like, como Linux e BSD. No Windows, alguns destes comandos podem apresentar comportamentos diferentes ou não funcionar.

Função os.GetEnv()

func Getenv(key string) string

A função Getenv retorna o valor da variável de ambiente especificada em key. Por exemplo, as variáveis de ambiente definidas na instalação do golang e do Visual Code, descritas no artigo Golang – 01. Introdução, são acessadas no seguinte código:

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	home := os.Getenv("HOME")
	path := os.Getenv("PATH")
	gopath := os.Getenv("GOPATH")
	gobin := os.Getenv("GOBIN")

	fmt.Printf("     HOME: %s\n", home)

	pathList := strings.Split(path, ":")
	lenPathList := len(pathList)
	fmt.Printf("PATH[-2:]: %v\n", pathList[lenPathList-2:])

	fmt.Printf("   GOPATH: %s\n", gopath)
	fmt.Printf("    GOBIN: %s\n", gobin)
}

A execução deste código deve retornar algo semelhante a:

     HOME: /home/alves
PATH[-2:]: [/home/alves/.bin /home/alves/go/bin]
   GOPATH: /home/alves/go
    GOBIN: /home/alves/go/bin

Note que o nome de usuário rudson deve ser substituído pelo seu usuário.

• Manipulação de Erros: É importante verificar se uma variável de ambiente existe antes de tentar utilizá-la. Usar os.LookupEnv pode ser uma opção mais segura, pois retorna um segundo valor booliano que indica se a variável de ambiente foi definida ou não.

func LookupEnv(key string) (string, bool)

• Performance e Melhores Práticas: Evite chamar os.Getenv repetidamente dentro de loops ou em funções chamadas frequentemente. Em vez disso, leia a variável de ambiente uma vez e armazene seu valor, especialmente se você não espera que ela mude durante a execução do seu programa.

Carregando Algumas Informações do Sistema

As funções a seguir fornecem informações úteis sobre o usuário, o processo e o sistema em execução. A tabela abaixo resume estas funções e seus retornos:

O código a seguir demonstra algumas destas funções em uso:

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println("           Group id:", os.Getgid())
    fmt.Println("          Group pid:", os.Getpid())
    fmt.Println("         Group ppid:", os.Getppid())
    fmt.Println("          Group uid:", os.Getuid())

    groupsList, err := os.Getgroups()
    if err != nil {
      fmt.Printf("Error retrieving groups list: %v\n", err)
    } else {
      fmt.Println("        Groups list:", groupsList)  
    }
    
    dirString, err := os.Getwd()
    if err != nil {
      fmt.Printf("Error retrieving current directory: %v\n", err)
    } else {
      fmt.Println("                pwd:", dirString)
    }

    hostname, err := os.Hostname()
    if err != nil {
      fmt.Printf("Error retrieving hostname: %v\n", err)
    } else {
      fmt.Println("           hostname:", hostname)
    }
}

Ao executar este código, o retorno em meu sistema é apresentado da seguinte forma:

           Group id: 1000
          Group pid: 11350
         Group ppid: 11207
          Group uid: 1000
        Groups list: [4 27 123 1000]
                pwd: /home/rudson/Documents/Studien/Go/testes
           hostname: suzail

Ao executar este código várias vezes, as saídas para pid e ppid serão diferentes e consistirão em inteiros crescentes, visto que novos processos são criados a cada execução. Os demais valores são informações fixas do sistema, usuário e grupo.

A lista de IDs retornada por os.Getgroups() corresponde aos IDs dos grupos declarados no arquivo de sistema /etc/group. Na próxima seção, desenvolverei um código para criar um mapa desses códigos de grupos com seus respectivos IDs.

• Dicas de Performance e Melhores Práticas: Lembre-se de que algumas informações do sistema, como o diretório atual ou o hostname, podem mudar durante a execução do programa. Portanto, se você precisa dessas informações atualizadas, deve chamar as funções apropriadas cada vez que precisar delas. Por outro lado, se você espera que esses valores permaneçam constantes, leia-os uma vez e reutilize o valor para evitar chamadas desnecessárias ao sistema.

Arquivos e Diretórios

Nesta seção, agrupei as funções relacionadas ao acesso e manipulação de arquivos e diretórios. Sob a perspectiva do pacote os, arquivos e diretórios têm tratamentos semelhantes, utilizando-se do mesmo descritor File. Por isso, ao longo deste texto, a referência a “arquivo” pode, em alguns momentos, aplicar-se tanto a arquivos quanto a diretórios.

É importante notar que, apesar dessa similaridade no tratamento pelo descritor File, arquivos e diretórios possuem suas particularidades e funções específicas dentro do sistema de arquivos. O pacote os oferece uma variedade de ferramentas poderosas para lidar com essas nuances, permitindo uma interação robusta e versátil com o sistema de arquivos do sistema operacional.

Funções Open, Create e OpenFile

O acesso a um arquivo ou diretório em Go é geralmente feito pelas funções:

func Open(name string) (*File, error)
func Create(name string) (*File, error)
func OpenFile(name string, flag int, perm FileMode) (*File, error)

Essas três funções retornam um descritor de arquivo (*File), que permite o acesso a vários métodos para manipular as informações do arquivo ou diretório.

O código a seguir acessa as informações do arquivo /etc/group do unix aberto pelo os.Open:

package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    file, err := os.Open("/etc/group")
    if err != nil {
        log.Fatal(err)
    }

    defer file.Close()

    fmt.Println(file.Name())
    fileInfo, _ := file.Stat()
    fmt.Println("   File Name:", fileInfo.Name())
    fmt.Println("        Size:", fileInfo.Size())
    fmt.Println("      Is dir:", fileInfo.IsDir())
    fmt.Println("        Mode:", fileInfo.Mode())
    fmt.Println("         Sys:", fileInfo.Sys())
    fmt.Println(" Modify time:", fileInfo.ModTime())
}

Sua execução retorna:

     File Name: group
         Size: 1200
       Is dir: false
         Mode: -rw-r--r--
          Sys: &{66309 267922 1 33188 0 0 0 0 1200 4096 8 {1650907746 277314560} {1650907746 281314651} {1650907746 281314651} [0 0 0]}
  Modify time: 2022-04-25 14:29:06.281314651 -0300 -03 

O os.OpenFile permite abrir um arquivo com mais controle, especificando o modo de abertura por meio da variável flag e as permissões do arquivo por meio do FileMode.

As flags possíveis são apresentadas na tabela abaixo:

Essas constantes são alias de constantes de mesmo nome no pacote syscall. Uma das três primeiras constantes deve obrigatoriamente aparecer na composição da flag a ser passada para o os.OpenFile.

O FileMode é composto de flags de modos do arquivo e bits de permissão. A lista completa de flags para o FileMode é apresentada abaixo:

Os noves “-” após a flag de modo corresponde as flags de permissão do arquivo que são “rwx” (read, write e exec) repetidas três vezes para especificar o acesso ao arquivo/diretório do proprietário, grupo e outros. A tabela a seguir apresenta alguns exemplos de flags de permissão.

O código a seguir criar um arquivo test.log, se não existir, e adiciona “append new data...” a cada execução:

package main

import (
    "log"
    "os"
)

func main() {
    file, err := os.OpenFile("test.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    
    defer file.Close()

    if _, err := file.Write([]byte("append new data...\n")); err != nil {
        log.Fatal(err)
    }
}

Execute no terminal para gerar o test.log no diretório do código. Após três execuções o arquivo terá três linhas com o conteúdo “append new data...“.

Função CreateTemp

Existe ainda outro método para criar arquivos, como o os.CreateTemp:

func CreateTemp(dir, pattern string) (*File, error)

O CreateTemp cria um novo arquivo temporário no diretório especificado por dir, abre o arquivo para leitura e escrita, e retorna o arquivo resultante. O nome do arquivo é gerado a partir do pattern string, adicionando uma string aleatória ao final. Se o pattern incluir um “”, a string aleatória substituirá o último “”. Se dir for uma string vazia, CreateTemp usará o diretório padrão para arquivos temporários, que no Unix é /tmp.

O código a seguir cria um arquivo temporário em /tmp/exemple.xxxxxx.txt e o remove antes de fechar o programa.

    file, err := os.CreateTemp("", "exemple.*.txt")
    if err != nil {
        log.Fatal(err)
    }

    defer file.Close()
    defer os.Remove(file.Name())  // Garante que o arquivo seja removido após o fechamento

    if _, err := file.Write([]byte("content")); err != nil {
        log.Fatal(err)
    }

    fmt.Println("Name: ", file.Name())
    stat, _ := file.Stat()
    fmt.Println("Size: ", stat.Size())
    fmt.Println("Time: ", stat.ModTime())
}

Caso deseje conferir o conteúdo do arquivo, comente a linha com defer os.Remove(file.Name()). A execução deste código deve retornar algo como:

 Name:  /tmp/exemple.2390896382.txt
 Size:  7
 Time:  2022-05-23 08:20:11.156918123 -0300 -03 

Nota: Outra função para criar arquivos é os.NewFile. No entanto, essa é uma função de baixo nível e geralmente não é usada diretamente, portanto não será abordada aqui.

Descritor File

O descritor de arquivos os.File oferece acesso a um conjunto de métodos que permitem interagir com o conteúdo do arquivo/diretório de maneira eficiente e segura. Conhecer esses métodos é fundamental para realizar operações de I/O, como ler e escrever em arquivos, alterar permissões e propriedades, e trabalhar com diretórios de maneira programática.

Alguns dos métodos disponíveis são:

Muitos desses métodos, como Close() e Write(), já foram utilizados nos exemplos anteriores. Vale ressaltar que, em algumas situações, o descritor de arquivo os.File pode se referir a um diretório, como no caso do ReadDir().

O exemplo de código a seguir ilustra como usar o método ReadDir() para listar o conteúdo do diretório HOME:

package main

import (
	"fmt"
	"log"
	"os"
)

func IsFile(d os.DirEntry) bool {
	return !d.IsDir()
}

func main() {
	home, exists := os.LookupEnv("HOME")
	if !exists {
    log.Fatal("Variável de sistema HOME não encontrada!")
  }

	dir, err := os.Open(home)
	if err != nil {
		log.Fatal(err)
	}

	fs, err := dir.ReadDir(-1)
	if err != nil {
		log.Fatal(err)
	}

	for _, dirEntry := range fs {
		if IsFile(dirEntry) {
			fmt.Println("file: ", dirEntry.Name())
		} else {
			fmt.Println(" dir: ", dirEntry.Name())
		}
	}
}

Este código irá listar os arquivos e diretórios no diretório HOME do usuário, classificando cada entrada como um arquivo ou diretório. A saída será uma lista personalizada do conteúdo do diretório, semelhante a:

 dir: .cache
file: .bash_prompt
file: Pictures
file: Unimed_Cancelamento.pdf
 dir: .fzf
 dir: Desktop
 dir: .quicktype-vscode
file: Book.pdf
file: Comunicado.pdf
…

Conhecer e utilizar esses métodos permite manipular o sistema de arquivos de forma poderosa e flexível, abrindo um leque de possibilidades para automação e gestão de arquivos e diretórios em aplicações Go.

Função ReadFile

Se o seu objetivo é ler o conteúdo inteiro de um arquivo de forma simples e eficiente, a função ReadFile é ideal.

func ReadFile(name string) ([]byte, error)

A função ReadFile lê o arquivo especificado por name e retorna o conteúdo como um slice de bytes ([]byte) e um código de erro, se houver algum. Uma chamada bem-sucedida retorna err igual a nil, e não EOF, já que ReadFile é projetada para ler o arquivo inteiro de uma só vez.

O código a seguir lê o conteúdo do arquivo /etc/group usando os.ReadFile e processa o conteúdo para mapear os grupos de usuário:

package main

import (
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

// Função que lê o arquivo "/etc/group" e mapeia os grupos.
func mapGroup() map[int]string {
	data, err := os.ReadFile("/etc/group")
	if err != nil {
		log.Fatal(err)
	}
	etcContents := strings.Split(string(data), "\n")

	groups := map[int]string{}
	for _, line := range etcContents {
		split := strings.Split(line, ":")
		if len(split) > 2 {
			index, err := strconv.Atoi(split[2])
			if err == nil {
				groups[index] = split[0]
			}
		}
	}

	return groups
}

func main() {
	// Chama a função mapGroup para mapear os grupos do sistema.
	groups := mapGroup()

	// Obtém o ID do usuário atual.
	userId := os.Getuid()

	// Obtém o ID do grupo atual.
	groupId := os.Getgid()

	// Obtém a lista de grupos adicionais aos quais o usuário pertence.
	groupsId, _ := os.Getgroups()
	groupsStr := []string{}
	for _, g := range groupsId {
		groupsStr = append(groupsStr, groups[g])
	}

	// Imprime as informações na saída padrão.
	fmt.Printf(" Username: %s\n", groups[userId])
	fmt.Printf("    Group: %s\n", groups[groupId])
	fmt.Printf("   Groups: %v\n", groupsStr)
}

Este exemplo demonstra como ler e processar o conteúdo de um arquivo. As linhas 11 a 30 definem a função mapGroup, que lê as informações do arquivo /etc/group e as retorna em um map[int]string. Esse mapa é usado para converter os IDs de grupos retornados pela função os.Getgroups() nos nomes dos grupos correspondentes.

O conteúdo completo do arquivo /etc/group é lido como um slice de bytes na linha 12. Esses bytes são então convertidos em uma string e as quebras de linha são usadas para separar as linhas do arquivo, resultando em um slice com as linhas do arquivo (linha 16).

As linhas 18 a 30 processam cada linha para extrair o ID e o nome do grupo, criando um mapa onde a chave é o ID do grupo (gid) e o valor é o nome do grupo. Isso permite que a função main converta os IDs de grupo em nomes de grupo de uma maneira legível e amigável.

Função WriteFile

A função os.WriteFile oferece uma maneira simples e direta de escrever dados em um arquivo.

func WriteFile(name string, data []byte, perm FileMode) error

A função WriteFile escreve o slice de bytes data no arquivo especificado por name, criando o arquivo se ele não existir. Se o arquivo já existir, WriteFile apaga seu conteúdo antes de escrever os novos dados, mantendo as permissões originais. O arquivo é criado com as permissões especificadas por perm, ajustadas de acordo com a umask do sistema.

O exemplo de código a seguir demonstra o uso de os.WriteFile para gravar um texto no arquivo arquivo.txt:

package main

import (
	"log"
	"os"
)

func main() {
	text := []string{
		"While traveling, Einstein wrote daily to his wife Elsa and ",
		"adopted stepdaughters Margot and Ilse. The letters were ",
		"included in the papers bequeathed to the Hebrew University ",
		"of Jerusalem...",
	}

	allText := ""
	for _, line := range text {
		allText += line + "\n"
	}

	data := []byte(allText)
	err := os.WriteFile("arquivo.txt", data, 0600)
	if err != nil {
		log.Fatal(err)
	}
}

Este código junta as linhas do texto do slice text em uma única string allText, e então converte essa string em um slice de bytes, que é escrito no arquivo arquivo.txt. A função os.WriteFile simplifica o processo, gerenciando a abertura, a escrita e o fechamento do arquivo automaticamente.

No entanto, é importante notar que, embora os.WriteFile seja conveniente para escrever dados de uma só vez, ela exige que todo o conteúdo do arquivo seja mantido na memória antes da escrita, o que pode ser ineficiente para arquivos grandes. Além disso, o conteúdo original do arquivo será substituído a cada execução do código.

Para comparação, o exemplo de código a seguir usa os.Create e WriteString para escrever os mesmos dados no arquivo test.txt:

package main

import (
	"log"
	"os"
)

func main() {
	text := []string{
		"While traveling, Einstein wrote daily to his wife Elsa and ",
		"adopted stepdaughters Margot and Ilse. The letters were ",
		"included in the papers bequeathed to the Hebrew University ",
		"of Jerusalem...",
	}

	file, err := os.Create("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	for _, line := range text {
		_, err := file.WriteString(line + "\n")
		if err != nil {
			log.Fatal(err)
		}
	}
}

Esta abordagem é um pouco mais complexa, pois requer o gerenciamento manual do arquivo, incluindo a abertura, a escrita de cada linha e o fechamento do arquivo. No entanto, permite um controle mais fino sobre o processo de escrita e pode ser mais eficiente para dados grandes ou para situações onde o controle sobre a escrita no arquivo é crítico.

Funções UserHomeDir, UserConfigDir e UserCacheDir

As funções UserHomeDir, UserConfigDir e UserCacheDir são utilitárias essenciais para acessar os diretórios padrão de home, config e cache de um usuário. Elas são particularmente úteis para aplicações que precisam armazenar ou acessar dados específicos do usuário de maneira que esteja em conformidade com as convenções do sistema operacional.

A tabela a seguir resume os caminhos retornados por UserHomeDir, UserConfigDir e UserCacheDir de acordo com o sistema operacional:

O código a seguir demonstra como usar essas funções:

package main

import (
    "fmt"
    "os"
)

func main() {
    home, err := os.UserHomeDir()
    if err != nil {
        fmt.Println("Error retrieving home directory:", err)
    }

    conf, err := os.UserConfigDir()
    if err != nil {
        fmt.Println("Error retrieving config directory:", err)
    }

    cache, err := os.UserCacheDir()
    if err != nil {
        fmt.Println("Error retrieving cache directory:", err)
    }

    fmt.Println("Home Directory:", home)
    fmt.Println("Config Directory:", conf)
    fmt.Println("Cache Directory:", cache)
}

Em um sistema Linux, por exemplo, a saída deste código pode ser:

/home/rudson
/home/rudson/.config
/home/rudson/.cache

Ao usar essas funções, é importante tratar erros apropriadamente, pois falhas na recuperação dos diretórios podem levar a comportamentos inesperados ou falhas na aplicação.

Pacote os/exec

O pacote exec do Go fornece funcionalidades para executar comandos externos, permitindo a interação do programa Go com o ambiente do sistema operacional. Diferente da função “system” da biblioteca C, o pacote exec não invoca o shell do sistema operacional e, consequentemente, não expande padrões glob (curingas como *, ?, […] e outros). Se for necessário expandir os padrões glob, você pode invocar o shell diretamente ou usar a função Glob do pacote path/filepath.

Função LookPath

func LookPath(file string) (string, error)

A função LookPath é usada para procurar pelo executável especificado em file nos diretórios listados na variável de ambiente PATH do sistema. Se file contiver um slash (/), LookPath tentará encontrar o executável no caminho exato especificado em file. O retorno da função é o caminho completo para o executável encontrado ou um erro, caso o comando não seja encontrado.

O exemplo de código a seguir demonstra o uso de LookPath para verificar a existência de vários comandos no sistema:

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	cmds := []string{"ls", "code", "guru", "g++", "blender"}

	for _, cmd := range cmds {
		path, err := exec.LookPath(cmd)
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("Command %q find in %q\n", cmd, path)
		}
	}
}

Em meu sistema este código retornou como:

Command "ls" find in "/usr/bin/ls"
Command "code" find in "/usr/bin/code"
Command "guru" find in "/home/alves/go/bin/guru"
Command "g++" find in "/usr/bin/g++"
exec: "blender": executable file not found in $PATH

A função LookPath é útil para validar a existência de comandos necessários antes de tentar executá-los, garantindo que seu programa não falhe inesperadamente devido à falta de ferramentas necessárias no ambiente do usuário.

Atributos da Cmd

A struct Cmd, criada pelas funções exec.Command e exec.CommandContext, encapsula informações detalhadas sobre comandos externos que serão executados. Essas informações incluem, mas não estão limitadas a, o caminho do executável, argumentos, variáveis de ambiente e canais para entrada e saída padrão. Entender e utilizar corretamente os atributos de Cmd permite um controle refinado sobre a execução de comandos externos, o que é crucial para a criação de aplicações seguras e eficientes.

Os atributos de um Cmd são listados e descritos na tabela a seguir:

O exemplo de código a seguir ilustra o uso de vários atributos da struct Cmd:

package main

import (
	"bytes"
	"fmt"
	"log"
	"os/exec"
)

func main() {
	cmd := exec.Command("head", "-n", "5", "/proc/cpuinfo")

	out := bytes.Buffer{}
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("cmd.Args: %v\n", cmd.Args)
	fmt.Printf("cmd.Dir: %v\n", cmd.Dir)
	fmt.Printf("cmd.Env: %v\n", cmd.Env)
	fmt.Printf("cmd.ExtraFiles: %v\n", cmd.ExtraFiles)
	fmt.Printf("cmd.Path: %v\n", cmd.Path)
	fmt.Printf("cmd.Process: %v\n", cmd.Process)
	fmt.Printf("cmd.Process Pid: %v\n", cmd.ProcessState.Pid())
	fmt.Printf("cmd.Process Success: %v\n", cmd.ProcessState.Success())
	fmt.Printf("\ncmd.Stdout:\n%v\n", cmd.Stdout)
}

Este código executa o comando “head -n 5 /proc/cpuinfo“, que imprime as primeiras 5 linhas das informações da CPU. O comando é preparado na linha 11 com a função exec.Command. Um buffer é criado na linha 13 para armazenar a saída padrão do comando. Ao atribuir esse buffer ao cmd.Stdout, garantimos que a saída do comando seja capturada pelo programa Go.

O comando é executado na linha 15 e, se houver algum erro, o programa é interrompido e o erro é registrado. As linhas subsequentes exibem os valores de vários atributos de cmd, demonstrando como informações detalhadas sobre a execução do comando podem ser acessadas e utilizadas.

A saída do código mostra não apenas a saída do comando head, mas também informações detalhadas sobre o processo criado para executar o comando, incluindo o caminho do executável, os argumentos passados, o PID do processo e se a execução do comando foi bem-sucedida.

cmd.Args: [head -n 5 /proc/cpuinfo]
cmd.Dir: 
cmd.Env: []
cmd.ExtraFiles: []
cmd.Path: /usr/bin/head
cmd.Process: &{52882 0 1 {{0 0} 0 0 0 0}}
cmd.Process Pid: 52882
cmd.Process Success: true

cmd.Stdout:
processor	: 0
vendor_id	: GenuineIntel
cpu family	: 6
model		: 141
model name	: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz

Função Command

A função Command do pacote os/exec é uma maneira poderosa de executar comandos externos a partir de um programa Go. Ela cria uma struct Cmd que encapsula as informações necessárias para executar o comando especificado em cmd com os argumentos args.

func Command(cmd string, args ...string) *Cmd

A struct Cmd armazena detalhes como o caminho do executável, argumentos, variáveis de ambiente e configurações para entrada/saída padrão, permitindo um controle detalhado sobre a execução do comando.

O exemplo de código a seguir executa o comando “ls -lah” no diretório $GOPATH/bin:

package main

import (
	"bytes"
	"fmt"
	"log"
	"os"
	"os/exec"
)

func main() {
	path := os.Getenv("GOPATH") + "/bin/" // ou somente "GOBIN", se o tiver definido
	cmd := exec.Command("ls", "-lah", path)

	var out bytes.Buffer
	cmd.Stdout = &out

	err := cmd.Run()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(out.String())
}

Este código demonstra a execução do comando ls com opções para listar detalhadamente os arquivos (-lah). O resultado é capturado em um buffer e exibido, mostrando os aplicativos instalados no diretório $GOBIN.

É importante notar que o pacote os/exec não suporta a expansão de curingas (*) diretamente. Isso significa que se você tentar passar um padrão glob como “go*” para listar apenas os arquivos que começam com go, o shell não expandirá o curinga e o comando falhará. Para lidar com isso, você pode invocar o shell diretamente ou usar a função Glob do pacote path/filepath para expandir os padrões antes de passá-los para o comando.

total 110M
drwxrwxr-x 2 rudson rudson 4.0K Jan 22 13:44 .
drwxrwxr-x 5 rudson rudson 4.0K Mar 17  2023 ..
-rwxrwxr-x 1 rudson rudson  20M Jan 16 08:05 dlv
-rwxrwxr-x 1 rudson rudson  12M Jan 16 08:06 gocode
-rwxrwxr-x 1 rudson rudson  16M Jan 16 14:59 godoc
-rwxrwxr-x 1 rudson rudson 5.3M Jan 16 08:06 goimports
-rwxrwxr-x 1 rudson rudson 5.7M Jan 16 08:06 golint
-rwxrwxr-x 1 rudson rudson  29M Jan 11 18:54 gopls
-rwxrwxr-x 1 rudson rudson 6.2M Jan 16 08:06 guru
-rwxrwxr-x 1 rudson rudson 7.1M Jan 22 13:44 page2md
-rwxrwxr-x 1 rudson rudson 1.8M Jan 15 12:31 secDeg
-rwxrwxr-x 1 rudson rudson 8.1M Jan 16 14:59 shadow

Função CommandContext

A função CommandContext oferece uma funcionalidade semelhante à Command, mas adiciona a capacidade de associar o comando a ser executado com um context.Context. Isso permite que o comando seja automaticamente terminado se o contexto for cancelado antes que o comando termine sua execução. É particularmente útil em cenários onde é necessário garantir que um comando não ultrapasse um determinado tempo de execução ou onde é importante poder cancelar a execução de comandos em resposta a eventos específicos.

func CommandContext(ctx context.Context, name string, arg ...string) *Cmd

O exemplo de código a seguir demonstra o uso de CommandContext para executar um comando com um limite de tempo definido pelo contexto:

package main

import (
    "context"
    "fmt"
    "log"
    "os/exec"
    "time"
)

func main() {
    // Cria um contexto que será cancelado automaticamente após 100 milissegundos
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()

    // Executa o comando 'sleep 5' com o contexto criado
    err := exec.CommandContext(ctx, "sleep", "5").Run()
    if err != nil {
        fmt.Println("Fail after 100 milliseconds!!!")
        log.Fatal(err)
    }

    fmt.Println("Sleep 5 sec finish...")
}

Neste código, criamos um contexto ctx que é cancelado automaticamente após 100 milissegundos. O comando sleep 5 é executado com esse contexto. Devido ao tempo de execução do comando ser maior que o tempo de timeout do contexto, o comando é interrompido e o programa termina com uma mensagem de erro.

O resultado esperado da execução deste código é:

Fail after 100 milliseconds!!!
2022/05/24 09:16:18 signal: killed
exit status 1

Ao usar CommandContext, é importante lembrar de criar e passar o contexto apropriado, bem como de tratar os erros que podem ser gerados quando o contexto cancela a execução do comando.

Métodos da Cmd

A struct Cmd fornece uma série de métodos para gerenciar e controlar a execução de comandos no sistema. Entre esses métodos, Output e CombinedOutput são particularmente úteis para capturar a saída de comandos.

Método Output e CombinedOutput

func (c *Cmd) Output() ([]byte, error)
func (c *Cmd) CombinedOutput() ([]byte, error)

O método Output executa o comando e retorna um slice de bytes contendo a saída padrão do comando. Em contrapartida, CombinedOutput executa o comando e retorna um slice de bytes que combina a saída padrão e a saída de erro, mesclando as duas.

Aqui está um exemplo prático demonstrando o uso de Output e CombinedOutput:

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "/root/", "/usr/")

    stdout, err := cmd.Output()
    if err != nil {
        log.Fatal(err)
    }
    // stdout, err := cmd.CombinedOutput()
    // if err != nil {
        // log.Fatal(err)
    // }
    
    fmt.Printf("%s\n", stdout)
}

Este código tenta listar o conteúdo das pastas /root/ e /usr/. A primeira pasta geralmente é restrita e pode gerar um erro de acesso, enquanto a segunda é acessível para leitura.

Com Output, apenas a saída padrão é capturada. Portanto, a saída do código apenas mostrará a listagem da pasta /usr, sem indicar o erro de acesso à pasta /root:

/usr/:
bin
games
include
lib
lib32
lib64 ...

Entretanto, se você usar CombinedOutput (descomentando as linhas relevantes), tanto a saída de erro quanto a saída padrão serão capturadas, e o erro de acesso à pasta /root/ será incluído na saída:

ls: não foi possível abrir o diretório '/root/': Permissão negada
/usr/:
bin
games
include
lib
lib32 ...

O método CombinedOutput é útil quando você deseja tratar a saída de erro de forma equivalente à saída padrão, semelhante ao que ocorreria ao redirecionar a saída padrão para a saída de erro em um shell usando “1>&2“.1>&2” ao final de um comando shell para conectar a saída padrão a saída de erro.

Médotos Run e String

Continuando nossa exploração da struct Cmd, vamos olhar mais de perto os métodos Run e String, que permitem controlar a execução do comando e obter uma representação textual do comando a ser executado, respectivamente.

func (c *Cmd) Run() error
func (c *Cmd) String() string

O método Run executa o comando e bloqueia até que o comando termine. É uma maneira simples de executar um comando quando você não precisa interagir com ele durante sua execução, apenas aguardar por sua conclusão. Por outro lado, o método String fornece uma representação em string do comando, incluindo o nome do comando e seus argumentos. Isso pode ser particularmente útil para logging, debugging ou apenas para entender o que exatamente será executado.

O exemplo a seguir ilustra o uso desses métodos para encadear a saída de um comando na entrada de outro, simulando um pipeline como você faria no shell:

ls -lah /usr | grep lib

package main

import (
	"bytes"
	"fmt"
	"log"
	"os/exec"
)

// Executa um "ls -lah /usr | grep lib"
func main() {
	// Define dois comandos a serem executados.
	cmd1 := exec.Command("ls", "-lah", "/usr")
	cmd2 := exec.Command("grep", "lib")

	// Cria duas buffers de bytes para capturar a saída dos comandos.
	b1 := bytes.Buffer{}
	b2 := bytes.Buffer{}

	// Define as saídas dos comandos para as buffers criadas.
	cmd1.Stdout = &b1
	cmd2.Stdin = &b1
	cmd2.Stdout = &b2

	// Executa o primeiro comando "ls -lah /usr".
	if err := cmd1.Run(); err != nil {
		log.Fatal(err)
	}
	// Imprime o comando executado e sua saída.
	fmt.Printf("%s:\n%s\n", cmd1.String(), b1.String())

	// Executa o segundo comando "grep lib" com base na saída do primeiro comando.
	if err := cmd2.Run(); err != nil {
		log.Fatal(err)
	}
	// Imprime o comando executado e sua saída.
	fmt.Printf("%s:\n%s\n", cmd2.String(), b2.String())
}

Neste exemplo, dois comandos são criados e encadeados. cmd1 executa “ls -lah /usr“, e sua saída é direcionada para b1. cmd2 executa “grep lib“, tomando a saída de cmd1 (contida em b1) como sua entrada e direcionando sua saída para b2. Os comandos são executados sequencialmente com Run, e o programa imprime as saídas capturadas junto com a representação em string dos comandos, oferecendo uma visão clara do que foi executado e do resultado.

A saída deste código é apresentada abaixo:

/usr/bin/ls -lah /usr:
total 176K
drwxr-xr-x  14 root root 4,0K mar  9 20:14 .
drwxr-xr-x  19 root root 4,0K abr 25 14:30 ..
drwxr-xr-x   2 root root  68K mai 23 23:46 bin
drwxr-xr-x   2 root root 4,0K mai  3 17:54 games
drwxr-xr-x  66 root root  16K mai 17 17:39 include
drwxr-xr-x 125 root root  12K mai 23 23:46 lib
drwxr-xr-x   2 root root 4,0K mar 23  2021 lib32
drwxr-xr-x   2 root root 4,0K abr 25 14:17 lib64
drwxr-xr-x  20 root root  12K mai 23 23:46 libexec
drwxr-xr-x   2 root root 4,0K mar 23  2021 libx32
drwxr-xr-x  10 root root 4,0K mar 23  2021 local
drwxr-xr-x   2 root root  20K mai 23 23:46 sbin
drwxr-xr-x 299 root root  12K mai 23 23:46 share
drwxr-xr-x  11 root root 4,0K mai  5 09:17 src

 /usr/bin/grep lib:
drwxr-xr-x 125 root root  12K mai 23 23:46 lib
drwxr-xr-x   2 root root 4,0K mar 23  2021 lib32
drwxr-xr-x   2 root root 4,0K abr 25 14:17 lib64
drwxr-xr-x  20 root root  12K mai 23 23:46 libexec
drwxr-xr-x   2 root root 4,0K mar 23  2021 libx32

Métodos Start e Wait

Os métodos Start e Wait da struct Cmd oferecem controle sobre a execução assíncrona de comandos. Start inicia o comando mas não bloqueia a execução do programa Go, permitindo que o programa continue executando outras operações em paralelo. Wait é usado para bloquear até que o comando iniciado com Start termine, garantindo que possíveis efeitos colaterais do comando sejam concluídos antes de prosseguir.

func (c *Cmd) Start() error
func (c *Cmd) Wait() error

O exemplo a seguir ilustra o uso de Start e Wait para executar um comando de forma assíncrona e, em seguida, esperar por sua conclusão:

package main

import (
    "bytes"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    home, err := os.UserHomeDir()
    if err != nil {
        log.Fatal(err)
    }

    cmd := exec.Command("ls", "-laRh", home)

    buffer := bytes.Buffer{}
    cmd.Stdout = &buffer

    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Executando um %s...\n", cmd.String())

    if err := cmd.Wait(); err != nil {
        log.Fatal(err)
    }

    fmt.Println("Terminou...")
    // Descomente a linha abaixo para imprimir o conteúdo do buffer.
    // fmt.Println(buffer.String())
}

Neste exemplo, o comando ls é executado no diretório raiz do usuário corrente. O método Start é chamado para iniciar a execução do comando, e a execução do programa Go continua, imprimindo “Executando um…”. Em seguida, Wait é chamado para garantir que o comando termine antes de imprimir “Terminou…”.

A saída do programa varia dependendo do conteúdo do diretório raiz do usuário e da velocidade do sistema de arquivos. O uso de buffer para capturar a saída do comando está demonstrado, mas o conteúdo do buffer não é impresso. Se você deseja ver a saída do comando, pode descomentar a linha que imprime o conteúdo do buffer.

Métodos StdinPipe, StdoutPipe e StderrPipe

func (c *Cmd) StdinPipe() (io.WriteCloser, error)
func (c *Cmd) StdoutPipe() (io.ReadCloser, error)
func (c *Cmd) StderrPipe() (io.ReadCloser, error)

Os métodos StdinPipe, StdoutPipe, e StderrPipe da struct Cmd são interfaces poderosas para interagir com os pipes padrão de entrada, saída e erro de um comando externo. Eles são particularmente úteis para operações de comunicação inter-processos, permitindo que seu programa Go interaja diretamente com a entrada, saída e mensagens de erro de comandos externos.

Esses métodos são essenciais para cenários avançados como:

• Encadeamento de Comandos (Piping): Você pode usar StdoutPipe de um comando para ler sua saída e StdinPipe de outro comando para fornecer essa saída como entrada, criando uma cadeia de comandos com comunicação direta.
• Captura de Erros: StderrPipe pode ser usado para capturar e processar mensagens de erro de um comando, permitindo um tratamento de erro mais sofisticado.

Aqui está um exemplo de como esses pipes podem ser usados para ler a saída de um comando:

package main

import (
    "io"
    "log"
    "os/exec"
    "bytes"
)

func main() {
    // Cria um comando para listar diretórios
    cmd := exec.Command("ls", "-la")

    // Cria um pipe para a saída padrão do comando
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }

    // Inicia o comando
    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }

    // Lê e imprime a saída do comando
    buf := new(bytes.Buffer)
    buf.ReadFrom(stdout)
    log.Println(buf.String())

    // Aguarda o comando terminar
    if err := cmd.Wait(); err != nil {
        log.Fatal(err)
    }
}

Neste exemplo, StdoutPipe é usado para criar um pipe para a saída padrão do comando “ls -la“. O comando é iniciado com Start, e a saída é lida e impressa. Finalmente, Wait é chamado para garantir que o comando termine antes que o programa Go continue.

Pacote os/user

O pacote os/user é uma ferramenta poderosa para obter informações sobre usuários e grupos em um sistema. Ele permite consultar informações detalhadas sobre usuários pelo nome ou pela ID, e também informações sobre grupos. Vamos explorar as funções principais para consultar usuários, e posteriormente, as consultas relacionadas a grupos.

Funções Current, Lookup e LookupId

Essas funções são utilizadas para consultar informações de usuários no sistema:

func Current() (*User, error)
func Lookup(username string) (*User, error)
func LookupId(uid string) (*User, error)

• Current retorna a struct User do usuário corrente.
• Lookup retorna a struct User do usuário pelo username especificado.
• LookupId retorna a struct User pelo uid do usuário.

A struct User possui os seguintes atributos e método:

O exemplo de código a seguir demonstra como carregar informações de usuários diretamente do arquivo /etc/passwd e como usar a função Lookup(username) para encontrar seus atributos no sistema:

package main

import (
	"fmt"
	"log"
	"os"
	"os/user"
	"strconv"
	"strings"
)

// Declaração de variáveis globais para armazenar informações de grupos e usuários.
var groups map[int]string
var sysUsers map[int]string

// Função init é executada automaticamente antes da função main.
func init() {
	// Inicializa o mapeamento de grupos e usuários a partir dos arquivos /etc/group e /etc/passwd.
	groups = mapGroupId()
	sysUsers = mapUsersId()
}

// mapFile é uma função genérica para mapear informações de um arquivo usando um separador e índices específicos.
func mapFile(fileName string, sep string, iInt int, iStr int) map[int]string {
	data, err := os.ReadFile(fileName)
	if err != nil {
		log.Fatal(err)
	}

	strData := strings.Split(string(data), "\n")
	outMap := map[int]string{}

	for _, line := range strData {
		split := strings.Split(line, sep)
		if len(split) > 2 {
			id, err := strconv.Atoi(split[iInt])
			if err == nil {
				outMap[id] = split[iStr]
			}
		}
	}
	return outMap
}

// mapGroupId mapeia informações de grupos a partir do arquivo /etc/group.
func mapGroupId() map[int]string {
	return mapFile("/etc/group", ":", 2, 0)
}

// mapUsersId mapeia informações de usuários a partir do arquivo /etc/passwd.
func mapUsersId() map[int]string {
	return mapFile("/etc/passwd", ":", 2, 0)
}

// id2GroupName converte IDs de grupos em nomes de grupos.
func id2GroupName(ids []string) (gNames []string) {
	for _, sgid := range ids {
		gid, _ := strconv.Atoi(sgid)
		gNames = append(gNames, groups[gid])
	}
	return
}

func main() {
	// Itera sobre os usuários do sistema com UIDs entre 1000 e 2000.
	for uid, username := range sysUsers {
		if uid >= 1000 && uid < 2000 {
			u, err := user.Lookup(username)
			if err != nil {
				log.Fatal(err)
			}
			fmt.Printf("    Name: %v\n", u.Name)
			fmt.Printf(" HomeDir: %v\n", u.HomeDir)
			fmt.Printf("     Uid: %v\n", u.Uid)
			fmt.Printf("Username: %v\n", u.Username)
			sgid, _ := u.GroupIds()
			myGroups := id2GroupName(sgid)
			fmt.Printf("GroupIds: %v\n\n", myGroups)
		}
	}
}

Funções LookupGroup, LookupGroupId e GroupIds

Essas funções são usadas para buscar informações de grupos no sistema:

func LookupGroup(name string) (*Group, error)
func LookupGroupId(gid string) (*Group, error)

LookupGroup e LookupGroupId procuram informações de grupos pelo nome ou pelo ID, respectivamente. Em sistemas Unix-like, essas funções buscam informações no arquivo /etc/group, de forma semelhante à função mapGroupId() no exemplo anterior.

A struct Group tem a seguinte definição:

type Group struct {
	Gid  string // group ID
	Name string // group name
}

A decisão de definir Gid e Uid como strings pode parecer incomum, mas oferece flexibilidade e compatibilidade em diferentes sistemas operacionais e contextos onde IDs podem não ser puramente numéricos.

O exemplo de código a seguir reimplementa o código anterior, usando a função LookupGroupId para transformar o Gid no Name do grupo:

package main

import (
	"fmt"
	"log"
	"os"
	"os/user"
	"strings"
)

// Declaração de uma variável global para armazenar informações de usuários do sistema.
var sysUsers map[string]string

// Função init é executada automaticamente antes da função main.
func init() {
	// Inicializa o mapeamento de usuários a partir do arquivo /etc/passwd.
	sysUsers = mapUsersId()
}

// mapFile é uma função genérica para mapear informações de um arquivo usando um separador e índices específicos.
func mapFile(fileName, sep string, iIndex, iName int) map[string]string {
	data, err := os.ReadFile(fileName)
	if err != nil {
		log.Fatal(err)
	}

	strData := strings.Split(string(data), "\n")
	outMap := map[string]string{}

	for _, line := range strData {
		split := strings.Split(line, sep)
		if len(split) > 2 {
			id := split[iIndex]
			outMap[id] = split[iName]
		}
	}
	return outMap
}

// mapUsersId mapeia informações de usuários a partir do arquivo /etc/passwd.
func mapUsersId() map[string]string {
	return mapFile("/etc/passwd", ":", 2, 0)
}

// id2GroupName converte IDs de grupos em nomes de grupos.
func id2GroupName(ids []string) (gNames []string) {
	for _, gid := range ids {
		group, err := user.LookupGroupId(gid)
		if err != nil {
			log.Fatal(err)
		}
		gNames = append(gNames, group.Name)
	}
	return
}

func main() {
	// Itera sobre os usuários do sistema com UIDs de quatro dígitos entre 1000 e 1999.
	for uid, username := range sysUsers {
		if len(uid) == 4 && uid >= "1000" && uid < "2000" {
			u, err := user.Lookup(username)
			if err != nil {
				log.Fatal(err)
			}
			fmt.Printf("    Name: %v\n", u.Name)
			fmt.Printf(" HomeDir: %v\n", u.HomeDir)
			fmt.Printf("     Uid: %v\n", u.Uid)
			fmt.Printf("Username: %v\n", u.Username)
			sgid, _ := u.GroupIds()
			myGroups := id2GroupName(sgid)
			fmt.Printf("GroupIds: %v\n\n", myGroups)
		}
	}
}

Esses exemplos demonstram como o pacote os/user pode ser usado para consultar informações detalhadas sobre usuários e grupos em um sistema, oferecendo funcionalidades poderosas para scripts e programas que precisam interagir com o ambiente do usuário.

Considerações Finais

Neste percurso através das funcionalidades do Go, exploramos uma variedade de pacotes e métodos que abrem um leque de possibilidades para interagir com o sistema operacional e executar comandos externos. Enquanto o pacote os/user nos proporcionou meios para acessar informações detalhadas sobre usuários e grupos, os pacotes os e os/exec mostraram-se ferramentas poderosas para o gerenciamento de arquivos, diretórios e execução de comandos externos com um controle refinado.

É importante notar que, embora o pacote os/signal não tenha sido abordado neste momento, ele detém sua relevância, especialmente em cenários onde é crucial monitorar e responder a sinais do sistema, como SIGKILL, SIGSTOP, ou eventos específicos do Windows como CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, ou CTRL_SHUTDOWN_EVENT. Para aplicações que necessitam dessa capacidade, recomendo enfaticamente a consulta e estudo da documentação do pacote os/signal para um entendimento abrangente e adequado da manipulação de sinais em Go.

Embora tenhamos coberto uma variedade significativa de funcionalidades, o universo do Go é extenso e há sempre mais para explorar e aprender. Existem outros pacotes e métodos que, por limitações de tempo e escopo, não foram explorados nesta ocasião, mas que sem dúvida merecem atenção em estudos futuros.

Este texto não é o ponto final, mas sim um ponto de partida. Encorajo os leitores a continuarem explorando, experimentando e aprendendo, pois é através da prática contínua e da curiosidade constante que se pode dominar a arte da programação em Go e aproveitar ao máximo seu potencial para criar aplicações robustas, eficientes e elegantes.