Arquivo → February, 2010
Grails: detalhes pouco conhecidos dos ambientes de execução (environments)
Um dos recursos mais bacanas do Grails é a possibilidade de se possuir mais de um ambiente de execução (environment). A grosso modo, pode-se dizer que o environment representa uma configuração específica de banco de dados usada em determinada situação. Neste post não irei explicar como configurar seu acesso às suas bases de dados, mas sim alguns pontos pouco divulgados a respeito deste recurso.
Você pode ter quantos ambientes quiser!
Por padrão Grails nos fornece três ambientes: test, development e production que, respectivamente, são usados quando executamos nossos testes unitários/de integração, estamos programando e, finalmente, enviamos para o servidor de aplicações no qual o produto final do nosso trabalho será usado. O que poucos sabem é que na realidade podemos ter quantos ambientes de execução quisermos!
Para adicionar um novo ambiente de execução, basta adicionar mais um bloco de código dentro da seção environments como no exemplo abaixo:
environments {
development {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:mysql://localhost/development"
}
}
test {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:mysql://localhost/test"
}
}
production {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:mysql://localhost/production"
}
}
meu_ambiente {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost/meu_BD_Louco"
}
}
}
Para usar estes ambientes de execução adicionais na linha de comando, basta usar a sintaxe abaixo:
grails [nome do ambiente] [comando]
Exemplo:
grails meu_ambiente run-app
Simples assim.
Descobrir qual o ambiente escolhido em tempo de execução
Grails só permite que um ambiente seja usado por vez. Sendo assim, esta é uma informação importante que podemos usar a nosso favor quando estamos programando. Suponhamos que seja interessante habilitar comportamentos apenas em alguns ambientes de execução. Como você faria? Assim:
import grails.util.Environmentswitch(Environment.current) {
case Environment.DEVELOPMENT:
"Apenas para desenvolvimento"
break
case Environment.PRODUCTION:
"Apenas para proução"
break
case "meu_environment"
"Olha o meu environment aqui!"
break
}
Environments na inicialização da aplicação
No arquivo grails-app/conf/Bootstrap.groovy incluimos o código que desejamos ser executado quando nossa aplicação é inicializada. Como tirar proveito dos ambientes de execução nesta situação? De novo, como no código abaixo:
def init = { ServletContext ctx ->
environments {
production {
// em produção
}
development {
// em desenvolvimento
}
}
ctx.setAttribute("foo", "bar")
}
Como instalar o Apache Cassandra
Recentemente enfrentei alguns problemas ao tentar instalar o Apache Cassandra. Como o getting started do projeto não me ajudou muito, aqui segue um guia rápido sobre como instalar o bichinho no seu computador/servidor.
1. Faça o download da última versão no site oficial: http://incubator.apache.org/cassandra/
2. Verifique os seus requisitos de sistema.
Como o Cassandra é feito em Java, o ideal é que você tenha a última versão do JRE instalado na sua máquina. No meu caso, usei o JDK 1.6.0_18. Caso você tenha no seu computador tanto o JDK quanto o JRE convencional instalado, recomendo que você defina a sua variável JAVA_HOME apontando para o diretório do JDK – ainda não está claro na documentação do Cassandra se o JDK é obrigatório.
3. Descompacte o conteúdo do arquivo baixado em um diretório de sua escolha
4. Crie uma variável de ambiente chamada CASSANDRA_HOME que aponte para o seu diretório de instalação do Cassandra
5. Edite o arquivo storage-conf.xml, que se encontra em CASSANDRA_HOME/conf
Neste arquivo encontram-se pré-configurados os diretórios nos quais o Cassandra irá armazenar os seus dados. O problema é que muito provávelmente estes diretórios não existem ainda no seu computador. Procure pelas tags CommitLogDirectory (que armazena o log de commits do Cassandra), DataFileDirectories (aonde seus dados serão armazenados), CalloutLocation e StagingFileDirectory
Como você verá, eles estão configurados para diretórios do tipo /var/cassandra, ou seja, já vieram pré-configurados para Linux. Se você está usando Windows, com certeza o Cassandra não irá funcionar de cara.
Há dois caminhos para solucionar o problema: Você pode criar a estrutura de diretórios exposta por estas tags ou simplesmente editá-las definindo aonde suas informações deverão ser armazenadas.
Feito isto o Cassandra executará perfeitamente no seu computador.
PS: bem que podia haver um instalador hein? Hmm…. (estalo na cabeça) :)
Grails Brasil {Blogs}
Este é um post bem rápido só para contar sobre o novo projeto da itexto: o Grails Brasil {Blogs}, que será o agregador de blogs da comunidade Grails Brasileira (e de língua portuguesa).
Os interessados em participarem do projeto (seja na codificação do crawler, seja divulgando seu blog) devem ler o post de lançamento no site da itexto cujo link é http://www.itexto.net/blog/?p=19 ou a partir do próprio site do projeto, cujo endereço é http://blogs.grailsbrasil.com.br
ps: final de fevereiro e início de março estão com algumas novidades BEM interessantes a caminho!
Grails: lista de recursos
De tempos em tempos alguém me pergunta aonde é possível aprender mais sobre Grails. Como basicamente sempre envio a mesma resposta – e o número destes e-mails tem crescido considerávelmente – acho que é uma boa idéia postar aqui uma pequena lista de sites/autores relacionados ao assunto para que vocês possam se aprofundar mais no assunto.
Inspiracional
O que me despertou para Grails foi uma palestra de Scott Davis (que produz MUITO material sobre o assunto, basta ver a lista abaixo) de 2007 entitulada “Groovy and Grails Intro”. Se você não sabe o que é Grails e quer ter uma idéia, sugiro que assista os dois vídeos abaixo:
Fontes básicas
Alguns recursos são fundamentais na minha opinião: se você está aprendendo Grails sem conhecê-los, é muito provável que esteja perdendo muito tempo.
Grails User Guide – http://grails.org/doc/latest – O guia do usuário oficial do framework é uma das peças de documentação mais bem escritas que conheço. Por si só já é mais do que suficiente para que qualquer um possa aprender – e bem – a trabalhar com Grails.
Getting Started With Grails (segunda edição) – eBook em formato PDF que pode ser baixado gratuitamente neste link – A primeira edição deste livro foi escrita por Jason Rudolph, e a segunda conta com a participação do Scott Davis. Faz juz ao nome, pois após sua leitura o leitor já está apto a começar (o livro não se aprofunda) a trabalhar com Grails. Leitura obrigatória.
Série Mastering Grails, de Scott Davis – IBM DeveloperWorks – link – Série de artigos publicados na DeveloperWorks por Scott Davis desde antes da versão 1.0 do Grails que foca em detalhes do funcionamento do framework que vão desde o básico do GORM até criação de plugins.
Série Pracitally Groovy, também de Scott Davis – IBM DeveloperWorks – link – Nesta série de artigos são abordados temas diretamente ligados ao dia a dia de quem trabalha com a linguagem Groovy, como por exemplo procesamento de arquvios XML, metaprogramação, etc. É interessante salientar a importância histórica desta série, que existe desde 2004, ficou parada por um tempo e foi em seguida retomada em 2009. É um excelente ponto de partida para quem deseja se aprofundar na linguagem.
Livro Groovy in Action – Traduzido para o português pela editora Alta Books como “Groovy em Ação” – Dierk König – Aprender Groovy é fundamental. Sim, é muito parecido com Java mas não implica que seja igual. Conhecer as nuancias da linguagem é de extrema importância. Esta edição é de 2007 (a tradução não é tão terrível como as demais da mesma editora) mas fornece uma excelente base para a compreensão da linguagem (e uma brevíssima introdução ao Grails pré 1.0)
Vídeo aulas: Grails do Início ao Fim – http://aulas.itexto.com.br – Publiquei em 2008/2009 um curso introdutório sobre Grails para a editora DevMedia que fez um certo sucesso e, acredito, pode ser de grande valia a quem esteja iniciando.
Aonde encontrar ajuda
Passada a teoria entra a prática. No seu dia a dia é fundamental que você troque idéias com outros profissionais que estejam trabalhando com a ferramenta. Minhas sugestões neste caso são as seguintes:
Grails Brasil – http://www.grailsbrasil.com.br – Iniciei o Grails Brasil em 2008 e atualmente contamos com mais de 600 membros. Acredito que uns 80% dos problemas que iniciantes enfrentem no seu aprendizado já se encontre em nosso banco de dados. Sendo assim, é sempre conveniente ao encontrar problemas pesquisar neste site.
Stack Overflow – http://www.stackoverflow.com – Não só problemas relacionados a Grails, mas com basicamente todas as linguagens de programação, frameworks, bibliotecas ou qualquer problema de programação que você sonhar. De todos os fórums que conheço, é sem dúvidas o melhor (em inglês).
Listas de discussão por e-mail – link – Você também pode encontrar ajuda nas listas de discussão por e-mail oficiais do Grails, que são excelentes e são um excelente modo de se conhecer usuários mais experientes também.
Blogs
Blogs são fundamentais para o aprendizado e atualização, porque neles podemos ver o que os reais usuários do Grails estão fazendo com a ferramenta. Como são vários – e não quero correr o risco de desmerecer alguém devido a um lapso de minha memória – acredito que o ideal seja que você mesmo escolha a partir de um dos agregadores de blogs abaixo:
GroovyBlogs – http://www.groovyblogs.org – É um agregador de blogs que, como este, são voltados para assuntos relacionados a Groovy e Grails
DZone – http://www.dzone.com – Outro agregador de blogs sobre desenvolvimento de sistemas muito interessante, e que possui uma seção voltada para Groovy/Grails
InfoBlogs – http://www.infoblogs.com.br – Agregador de blogs nacional que possui uma seção também dedicada a Groovy e Grails – link (nota: no caso do InfoBlogs, já vi diversos posts meus sobre Grails não aparecerem nesta seção, mas apenas na página principal)
Grails Brasil {Blogs} – http://blogs.grailsbrasil.com.br – Agregador de blogs nacionais relacionados a Grails mantido pela comunidade Grails Brasil.
Finalmente
Claro que não é necessário que você leia todas estas fontes, apenas o Grails User Guide já é mais do que o suficiente, porém é importante lembrar que na nossa área não existem fórmulas prontas. Grails só parece simples em um primeiro momento porque banaliza algumas tarefas repetitivas. O que diferencia um bom profissional do mediocre (ou abaixo disto) é o conhecimento adquirido.
Sendo assim, fica ai a lista de recursos básicos. Bom proveito!
Pascal e o nerd tiraninho
Monsieur Pascal
E não é que Pascal, no século XVII, ao expor o seu conceito de tirania sem querer descreve os nerds tiraninhos que implicam com todos aqueles que usam tecnologias diferentes das suas favoritas em pleno século XXI?
A definição é feita no fragmento 58 da sua obra inacabada “Pensées” (em português “Pensamentos”). Segue o fragmento:
“A tirania consiste no desejo de domínio universal e fora da sua ordem.
Diversos comportamentos de fortes, de belos, de bons espíritos, de piedosos, dos quaqis cada um reina na sua parte, não noutra parte. E às vezes se encontram, e o forte se bate com o belo como tolos disputando quem terá o domínio do outro, porque o seu domínio é de gênero diverso. Não se entendem. E o erro deles está em querer reinar por toda parte. Nada o pode, nem mesmo a força: ela nada faz no reino dos sábios, ela só tem o domínio das ações exteriores. – Assim, estes discursos são falsos…”
Resumindo, para Pascal a tirania consiste na tentativa de se negar a natureza própria das coisas – toscamente falando, consiste em tentar encaixar retãngulos em circulos. O tirano pode até mesmo conseguir, mas nunca terá um resultado BOM de fato.
E aonde o nerd tiraninho entra nesta?
Com certeza você já viu discussões em fórums do tipo “Java vs. .net”, “Mac vs. PC”, “Linux vs. Windows”, “X vs Y” que raríssimas vezes (eu nunca vi) resultam em alguma conclusão válida. E a razão é muito simples: uma tecnologia é criada visando resolver um conjunto de problemas (ou apenas um) específico, e não todos. A negligência deste fato é que torna a discussão idiota.
Será que estes tiraninhos tiveram brinquedos de encaixe na infância?
Nesta nossa área de TI é muito comum a ocorrência deste sentimento infantil de fascinação por uma tecnologia específica. A impressão que tenho é a de que os “profissionais” se tornam crianças, e a tecnologia em foco passa a ser vista como um martelo para o qual todos os problemas são pregos.
Vou dar um exemplo (é apenas um exemplo, por favor não vamos abordar este tema aqui ok?) de discussão recente: “.net é melhor que Java porque se integra melhor em forma nativa com Windows”. Fica nítido aqui o que Pascal disse acima?
- Java foi criado para ser multiplataforma, e não oferecer integração nativa profunda com nenhum sistema operacional específico (até consegue, mas não é algo nativo da plataforma).
- .net foi criado com o objetivo de substituir a API Win32 do Windows e oferecer um novo ambiente de execução/desenvolvimento para o ecosistema Microsoft (o papo multiplatforma sempre foi balela desde o início, convenhamos)
Percebem? Objetivos distintos. Não há como dizer que um seja superior ao outro levando este aspecto em consideração. Se a discussão fosse algo do tipo “qual ambiente de código gerenciado oferece maior segurança”, ai sim um poderia ser superior ao outro, pois um dos objetivos em comum entre as duas plataformas é justamente oferecer melhor segurança. Infelizmente, ESTE tipo de discussão é raro.
Não: o seu Java não vai resolver todos os problemas do mundo, assim como o seu .net, e o seu amado Delphi não é a ferramenta mais produtiva do universo em todos os aspectos, assim como o seu Ruby on Rails ou Grails. A tecnologia só se destaca de FATO para o conjunto de objetivos ao qual VISA atender.
Sendo assim, por favor, lembre-se: no mundo não há só pregos: há porcas, parafusos e muitas outras pecinhas.
PS:
e convenhamos, tiraninhos normalmente são muito chatos…
PS2:
e este papo de que “linguagem é tudo igual” também é furado demais da conta…
Segundo artigo da série “Grails: do Groovy à Web” publicado na Java Magazine
Meu segundo artigo da série “Grails: do Groovy à Web” acaba de ser publicado na edição digital da Revista Java Magazine, o que quer dizer que a versão impressa já deve (provávelmente já está) estar sendo distribuida neste momento.
Continuando a nossa jornada, desta vez exponho uma visão panorâmica do framework. Será apresentado o projeto que nos acompanhará nos próximos 3 artigos, que é o GBlog: um gerenciador de blogs simples o suficiente para que principiantes possam compreender o framework, mas complexo o suficiente para que possamos nos aprofundar nas 3 camadas que compõem o nosso framework: controle, modelo e visualização, que serão o assunto das edições 77, 78 e 79 da revista.
Espero que gostem da série (aguardo o feedback de vocês). Um grande abraço!
