Golang

Este é um erro bem difícil de achar, basicamente a ordem dos cases do switch esta errada, o maior escopo esta em primeiro lugar fazendo com que o switch sempre pare nele, para resolver o problema basta mudar a ordem dos cases colocando os casos de menor escopo no início. Mas até ai já foi um tempão debugando código e litros de café :D package main import "fmt" type comptometer interface { Sum(a, b int) int } type foo struct{} func (_ foo) Sum(a, b int) int { return a + b } type bar struct{} func (_ bar) Sum(a, b int) int { return a + b } // func printType(e comptometer) { /* Este switch esta na ordem errada e vai imprimir sempre "comptometer interface" e nunca via entrar nos outros cases do switch.

Testes unitários são incrivelmente importantes, mesmo para uma linguagem compilada como Golang eles são fundamentais. Felizmente hoje em dia a maioria das linguagens de programação tem uma bela variedade de ferramentas para teste unitário. Golang vem com algumas ferramentas surpreendentes não apenas para fazer os testes mas também para analisar o código em busca de falhas na cobertura, etc. E no lugar de simplesmente ler um relatório é muito mais interessante ter uma forma visual e rápida para analisar a cobertura de testes.

Imprimindo seu proprio fonte Quine é um programa que consegue imprimir seu código fonte na saída padrão. O nome é em homenagem ao matemático e filosofo Willard Van Orman Quine. Existem exemplos de Quine escritos para várias linguagens de programação, é um exercício interessante tentar escrever a sua versão e um belo desafio. Implementação em Golang package main func main() { aspa := string(96) print(codigo, aspa, codigo, aspa) } const codigo = `package main func main() { aspa := string(96) print(codigo, aspa, codigo, aspa) } const codigo = ` Codigo fonte do exemplo: exemplo no Golang Playground exemplo no grupo de estudos

Criando o certificado Primeiro vamos criar um certificado de testes, claro que quando for usar em produção você deve usar um certificado gerado por uma entidade certificadora reconhecida. Com o comando abaixo vamos criar dois arquivos server.crt e server.key que vamos usar para configurar o PostgreSQL. openssl req -new -x509 -days 365 -nodes -text -out server.crt \ -keyout server.key -subj "/CN=example.com" Configurando PostgreSQL Edite o arquivo postgresql.conf para ativar o uso da chave SSL.

Unix domain socket Unix Domain Sockets ou IPC socket é uma forma muito pratica e segura de trocar informações entre processos. Essa forma de IPC usa um arquivo como endereço/name space no lugar de um IP e uma porta como seria em uma comunicação via rede. Uma coisa importante para ter em mente é que como vamos usar um arquivo o servidor é responsável por ele, se não existir ele sera criado automaticamente mas se não existir você vai receber um erro com algo como “bind: address already in use” que significa que o arquivo já existe e o servidor não tem como reaproveitar um arquivo que já existe, o correto é fazer shutdown elegantemente e fechar e apagar o arquivo antes de derrubar o servidor.

Um JSON lint em Golang Esse é um pequeno utilitário de linha de comando para validar e formatar JSON que também pode ser usado como pacote, a ideia inicial era criar um parser para validar o JSON mas não foi necessário, o próprio Golang traz todas as informações que precisamos no erro inclusive o offset do erro e dai foi simples mostrar os erros de forma mais completa inclusive indicando com uma seta exatamente onde esta o erro.

Trafegando dados entre middleware Já vimos como funciona um middleware HTTP e agora vamos ver como passar informação entre os middlewares. Isso é usado por exemplo para passar as credenciais de um usuário para o próximo middleware e qualquer outra informação que seja coletada em algum dos middlewares e você queria passar para frente. Antes de mais nada vamos fazer um exemplo para mostrar da forma mais clara possível quando os middlewares são executados, isso é muito importante porque erros no entendimento dessa ordem de execução é uma incrível fonte de bugs.

Usar middleware HTTP são muito úteis para evitar duplicidade de código quando você tem vários endpoints na sua aplicação, por exemplo se você quiser ter certeza que as credenciais do usuário foram verificadas, ou que o conteúdo foi comprimido, e assim por diante. A coisa mais importante que se deve lembrar é que cada middleware vai ser chamado na ordem que foi registrado, então por exemplo podemos ter um middleware que tem a responsabilidade de preparar o ambiente, como abrir o banco de dados ou preparar o controle de sessão que vem antes do middleware que valida as credenciais do usuário.

goto e label em Go A instrução goto tem uma má fama que vem do tempo do BASIC quando era usada indiscriminadamente e acabava tornando o código impossível de ler. Em linguagens modernas entretanto é uma instrução perfeitamente válida e desde que usada com critério pode ajudar a tornar seu código mais limpo. Alem de goto as instruções break e continue também aceitam labels, isso é muito útil para quando por exemplo se quer sair de um for aninhado em outro for ou especificar para qual dos fors aninhados se quer fazer continue.

mensageria com NATS Para quem precisa que vários sistemas se comuniquem entre si e precisa de velocidade e simplicidade o NATS é uma grande ajuda. Uma das características mais interessantes é a incrível velocidade e um protocolo simples que pode ser facilmente implementado faz com que o NATS seja usado desde para IoT com bibliotecas cliente escritas até mesmo para Arduino quando para comunicação entre serviços muito maiores.

Este é o primeiro de uma série de tutoriais rápidos onde pretendo cobrir o uso de gRPC e vários aspectos como testes, TLS, boas praticas e muito mais. Para iniciar com gRPC precisamos ir até a base então vamos primeiro falar de Protocol Buffers. Protocol Buffers é uma forma simples e agnóstica com relação a linguagem de se definir uma estrutura de dados, como XML só que melhor, mais simples e mais rápido, muito mais rápido.

Continuando a conversa sobre interfaces e sobre manipulação de JSON tem um recurso muito útil que usamos para ajudar o nosso sistema a falar melhor com o PostgresQL e pREST. O formato de data padrão do Postgres é incompatível com o formato padrão do Golang e o nosso sistema usa muito JSON para tanto mandar como receber informações do banco de dados. Ter que lembrar toda hora de fazer o parser da data para o formato correto simplesmente não é pratico, é muito melhor ensinar o Golang como lidar com data e hora no bom e velho formato ISO 8601.

Falamos desse mesmo tema na nossa lista de exemplos do grupo de estudos sobre interfaces mas vamos isso foi la no longínquo ano de 2016 então vamos tentar fazer um novo exemplo para mostrar como usar uma interface como um contrato que permite você passar tipos diferentes para uma função ou aceitar tipos diferentes em uma interface desde que ele aceite implemente o contrato que em outras palavras significa implementar as funções descritas na interface.

Interface vazia é um tipo que aceita qualquer coisa, você pode passar o que quiser como parâmetros de função ou variáveis do tipo interface{}. Parece muito pratico a primeira vista mas quando usamos interface{} estamos jogando pela janela a validação de tipos feita em tempo de compilação e perdemos uma das grandes vantagens de uma linguagem compilada de tipagem forte e estática. E como a checagem de tipo não vai acontecer em tempo de compilação é sua responsabilidade checar se esta recebendo o tipo certo em tempo de execução.

Convertendo e validando JSON É sempre bom saber se o JSON é valido antes, isso poupa tempo de debug procurando um problema que não esta no seu código, para isso uma boa ferramenta on-line é o JSONLint Outra ferramenta on-line muito boa é o JSON-to-Go para converter arquivos JSON em struct Go, ele não vai converter partes repetitivas em sub-structs mas ajuda muito, principalmente quando a estrutura é muito grande e complexa.

Precisei criar um pacote Golang para ao Dropbox e fazer algumas operações basicas, listar arquivos, upload e download, para isso usei o dropbox-sdk-go-unofficial. Conectando Dropbox Para conectar o dropbox precisamos das credenciais de acesso, a forma mais fácil é criar um token, para isso entre em Dropbox developers apps e crie uma aplicação, então dentro do painel da aplicação crie o token. Configurando o sistema Todas as funções precisam das configurações com as credenciais de acesso e outros parâmetros úteis como por exemplo o nível de log.

Como carregar containers Docker usando gofn Primeiro instanciamos a struct BuildOptions que vai informar para o gofn os detalhes do container como o nome da imagem por exemplo. buildOpts := &provision.BuildOptions{ ImageName: "nome da imagem aqui", StdIN: "o que você quer passar no stdin para o container aqui", DoNotUsePrefixImageName: true, } Depois instanciamos as opções do container por exemplo se você quer passar variáveis de ambiente.

Criando executáveis monolíticos Golang já faz um bom trabalho compilando estaticamente praticamente tudo, mas dependendo do seu código é necessário incluir mais alguns parâmetros para garantir que seu executável seja totalmente livre de dependências. A primeira coisa é compilar o seu projeto e então inspecionar o binário para ver se ele tem alguma dependência. Para fazer isso no macOS usamos o utilitário otool (object file displaying tool) passando o parâmetro -L (mostra as shared libraries usadas) como no exemplo:

No canal Test After Deploy tivemos uma ótima explicação do funcionamento do tmux. E para mim uma das coisas mais interessantes é que os desenvolvedores preferiram deixar de fora algumas coisas que tem no screen, como o suporte a telnet e a portas seriais, eles fizeram isso porque acreditam na filosofia UNIX de faça apenas uma coisa e faça bem feito. E na minha opinião eles estão muito certos.

Brincando com bits Estou brincando com um projeto de um interpretador BASIC escrito em Go e a saída de video em modo texto segue o padrão de cores do CGA ou seja um byte contem nos quatro bits mais altos o código para a cor do fundo e nos quatro bits mais baixos o código para a cor da fonte. Ou seja 16 cores para as letras e 16 cores para o fundo.

Por que? Você deve estar se perguntando algo como “por que diabos um interpretador BASIC nos dias de hoje?“. Bom já a algum tempo eu estava querendo uma maquina para ensinar os princípios da computação para minha filha, e precisa ser uma maquina resistente, para resistir a uma criança de 5 anos tem que praticamente ser um tanque de guerra, e não pode ter nada sofisticado em termos de sistema operacional, nada de Linux ou Windows porque a maquina não pode ter um sistema de arquivos montado que precise ser desligado corretamente, precisa ser algo que seja desligado simplesmente cortando o fornecimento de energia e que ligue instantaneamente caindo em um prompt de alguma linguagem simples, sem ícones sem comandos para carregar o interpretador, nada, ligou ta pronto para receber comandos.

Defer Usar defer e poder adiar um comando para ser executado apenas quando a função terminar não importando a forma como ela terminar é uma grande ideia. Imagine uma função com vários pontos de retorno, seja para retornar erros ou porque ela terminou corretamente, ficar gerenciando fechar arquivos, conexões, mutex e o que mais você estiver usando em cada retorno é entediante e inseguro, você pode esquecer um dos retornos, e pode apostar que esse único retorno que você esqueceu é que vai tirar horas do seu sono.

No projeto do Ricardo Gomes onde ganhamos uma bela performace também acabamos acidentalmente incluindo uma bela data race. Data race acontece quando você tem acessos simultâneos a mesma variável por duas threads diferentes. Mas Golang tem ferramentas para tudo, e nessa brincadeira eu aprendi sobre o parâmetro -race. Esse parâmetro faz com que o Golang procure por possíveis data races em seu código e pode ser usado com test, run, build e install.

No ultimo domingo eu e o Ricardo Gomes da Fix Auditoria fizemos pair programming com a missão de melhorar o parse de EFD Fiscal que ele esta desenvolvendo em Golang. O nosso objetivo era fazer o parser ganhar alguma performace e também resolver alguns pequenos problemas na carga dos arquivos. O que o sistema faz até o momento é o seguinte: Le vários arquivos texto contendo centenas de milhares de registros, parseia esse conteúdo linha a linha e por fim grava tudo no banco de dados.

Eu estava com um problema de ter que digitar o caminho completo para chegar no diretório do projeto que eu queria trabalhar, esta tudo no GOPATH e os caminhos geralmente são longos. Tudo bem digitar todo o caminho uma vez ou outra, mas como estou trabalhando todo dia com golang e em mais de um projeto ter que digitar o caminho completo rapidamente se torna uma tarefa entediante. E as vezes eu nem sei onde exatamente o projeto esta, as vezes não lembro alguma parte do path como o nome do autor ou se esta no GitHub ou em outro repositório.

goconfig goconfig é um pacote para tornar fácil implementar as três principais formas de configuração de um sistema, ou seja, ler parâmetros da linha de comando, variáveis de ambiente e arquivos de configuração. A ideia é tornar a lentura da configuração bem simples porque a tendência a complexidade do seu sistema aumentar e não tem porque ter mais complexidade só porque você quer adicionar mais um parâmetro ou mais uma variável de ambiente.

Lexer, tokenizer, scanner… Tenho vários projetos que poderiam se beneficiar de um lexer genérico e escrito em Go, então resolvi brincar com a ideia de escrever o meu próprio. Eu sei, eu poderia ter usado text/scanner mas depois de alguns testes achei ele difícil de expandir, também poderia ter usado um dos muitos que estão prontos por ai, mas não encontrei nada que eu não precisasse aprender uma nova ferramenta alem da linguagem ou mergulhar na mente do criador original para entender o que ele queria fazer.

Pacote time Eu sou o primeiro a torcer o nariz para o pacote time, principalmente pela maneira como a formatação de datas é feita, mas um recurso muito interessante é poder criar um canal que retorna a cada X tempo e assim podemos executar ações periódicas. Veja como isso é feito Primeiro criamos um canal que vai retornar a cada X tempo, no caso do exemplo 300 milissegundos.

Plugins A possibilidade de criar plugins é um novo recurso da versão 1.8 que por enquanto funciona apenas no Linux. Um plugin basicamente é uma biblioteca externa que pode ser carregada dinamicamente, o uso é bem simples. O mesmo recurso deve ser incluso no macOS na versão 1.9 e provavelmente em outras plataformas. Por enquanto para todos poderem experimentar sugerimos subir um container Docker. O comando abaixo abre um container Docker com uma maquina virtual pronta para executar a versão 1.

Já tem algum tempo eu estava desenvolvendo um projeto usando a DISCO-F746NG, uma placa bem interessante e com muitos recursos. Um dos recursos mais legais é o LCD-TFT com 4.3” e multi-touch. E a programação da placa é feita usando mbed que é um ambiente bastante bom apesar de eu torcer o nariz para ele. Apesar de muitas qualidades essa placa não tem recursos muito avançados para tratamento de imagem via hardware, para desenhar você simplesmente escreve na memória de vídeo… no bom e velho estilo dos anos 90 gravando pixel a pixel :D

Este é mais um post da serie falando sobre Golang com Intel Edison, e estou usando bastante do que já falei em outros posts como tratamento de sinais por exemplo. Para gerar o sinal analógico vamos usar um potenciômetro, ou melhor RAS, Rotary Angle Sensor :D. O estilo do código é muito parecido com o que fizemos para gerar sinais PWM, mas agora a operação é de leitura. Lendo valores analógicos com MRAA.

PWM ou Pulse Width Modulation tem uma gama enorme de aplicações, usamos para controlar servos, definir o brilho de LEDs, potência de motores, regular tenção, efeitos sonoros e por ai vai. PWD com MRAA Como de costume poderíamos ter chamado diretamente as funções da MRAA, mas daí o código fica muito mais confuso, uma pratica melhor é dividir o programa em múltiplos arquivos. Primeiro o cabeçalho pwm.h que vai ser usado para incluir as funções C no código Go.

Tratar sinais é uma boa pratica, dessa forma você pode finalizar seu programa graciosamente, liberando recursos, fechando banco de dados, etc. muito melhor que simplesmente fechar o programa. E tratar sinais do sistema operacional com Golang é muito simples porque basicamente o sistema vai jogar o sinal em uma canal e então precisamos apenas ficar escutando. Primeiro criamos um canal sc := make(chan os.Signal, 1) Daí informamos qual o tipo de sinal estamos interessados, no caso ^C ou seja SIGINT.

Continuando com a diversão com o Intel Edison e a linguagem Go, esse é um pequeno exemplo de como ler o estado de um botão e usar esse estado para exibir uma mensagem na tela e para acender um LED. Para facilitar o entendimento vamos ver duas formas de implementação, uma com tudo em um único arquivo e outra com um código mais organizado. Primeiro exemplo Crie um arquivo com o nome button.

Eu quero emitir alertas sonoros no meu projeto de controle IoT e para isso eu precisava entender como a classe buzzer da biblioteca UPM funciona, dava para fazer tudo usando apenas a MRAA afinal é apenas um PWM em um terminal, mas vale a pena usar a UPM pois já vou usar para coisas mais pesadas como controle de periféricos i2c por exemplo. Outro motivo para esse pequeno tutorial é que a UPM tem vários recursos e bons exemplos mas não encontrei nenhum lugar explicando como compilar apenas usando os recursos do próprio Edison com uma simples linha de comando ou no máximo com um pequeno Makefile.

Gerando as chaves com letsencrypt.org Como eu mencionei no post sobre redirecionar tudo para HTTPS todas as comunicações entre cliente e servidor precisam ser criptografadas e com letsencrypt.org isso pode ser feito sem custo, com código aberto e muita documentação, o que no meu ponto de vista acaba com todas as desculpas para não usar HTTPS. Uma ressalva importante é que podem haver razões legais para preferir usar outra entidade certificadora, por exemplo se eu não estou enganado para ter valor legal no Brasil a entidade precisa ser brasileira.

Tudo criptografado! Sem desculpas! Antigamente era caro e inconveniente exigir criptografia para servidores HTTP, você teria que no mínimo gastar alguns trocados com uma entidade certificadora. De um tempo para cá isso não é mais verdade, qualquer um pode usar os certificados da letsencrypt.org, é free, fácil de usar e as ferramentas são de código aberto, então não existe mais desculpa para não usar HTTPS nos seus servidores. Redirecionando para HTTPS Para redirecionar tudo os navegadores para a porta HTTPS eu escrevi um pequeno serviço em Golang que simplesmente retorna o código 301 Moved Permanently para o navegador do usuário e indico o novo local apenas substituindo o URL Scheme de HTTP para HTTPS, e deixo o resto do trabalho para o navegador.

Golang com Intel Edison A maioria dos tutoriais que encontrei na internet pedem para compilar Go, o que dá bastante trabalho e demora. Isso se você não esbarrar com alguma dependência como a versão do git por exemplo, ou então adicionar repositórios que muitas vezes estão desatualizados tornando o Yocto instável. É muito mais fácil você simplesmente fazer download da versão para 32 bits em golang.org Preparando o Edison Obviamente para seguir os passos nesse post seu Edison precisa estar configurado e conectado no seu wifi.

Gerar strings aleatórias extremamente útil, um recurso usado em inúmeros lugares como por exemplo criar chaves para registros em bancos de dados distribuídos sem medo de colisão entre registros, criar ID de controle de sessão, criar senhas e por ai vai. E apesar de ser uma tarefa simples, esconde alguns truques interessantes. Na verdade computadores não são bons para criar coisas aleatórias, eles são bons para criar coisas previsíveis e isso é exatamente o que não se quer quando o objetivo é criptografia e segurança.