Em um projeto em que estou trabalhando foi definido que iríamos utilizar o modelo do scrum para realizar acompanhamento de projetos da equipe.
A equipe em questão não é uma equipe de desenvolvimento de software e portanto precisamos encontrar uma ferramenta que possa ser adaptada para a nossa realidade que é mais relacionadas a planejamento de ambiente e suporte a ambiente de produção. Com isso em mente comecei uma avaliação de várias ferramentas que dão suporte ao processo de desenvolvimento de software com XP e Scrum para avaliar a que seria a de mais fácil customização para adotarmos no nosso dia a dia. As ferramentas que avaliei foram:
XPlanner, IceScrum, Scarab e o Pronto.
Dentre estas a que mais agradou e que vamos customizar para atender à nossa demanda foi o Pronto. Os principais pontos que fizeram com que utilizássemos o Pronto é sua facilidade de configuração, open source, simples e também por ser um projeto de Brasileiros.
Durante a configuração de nosso ambiente seguimos as instruções de download e instalação no site do Pronto para baixar os fontes e gerar nosso ambiente.
Durante o processo de configuração do ambiente conforme descrito na documentação do pronto, ocorre um erro ao tentar executar um comando do maven como por exemplo:
mvn eclipse:eclipse
ou
mvn package
O erro é causado pois existe uma dependência documentada no pom.xml do projeto e que não é encontrada que é a do bliki.wiki . Este pacote vem junto com a distribuição de códigos-fonte do pronto e encontra-se sob o diretório WEB-INF/lib . A versão que vem distribuída é a 3.0.11 e a referência no pom.xml é para a 3.0.13. Para corrigir o problema temos 2 opções. O primeiro passo para ambas as situações é corrigir a referência do pom para a versão 3.0.11 então onde está no pom.xml a entrada:
info.bliki.wikibliki-core3.0.13
Deve ser corrigido para referenciar a versão 3.0.11 que vem com os fontes do pronto.
Com isso a entrada no pom.xml fica assim:
info.bliki.wikibliki-core3.0.11
Feito isso temos duas opções, a primeira é instalar manualmente o pacote utilizando o comando do maven para tal e a segunda é encontrar um repositório que contenha as bibliotecas e registrá-la no nosso pom.xml. Procurei na web e não encontrei um repositório maven com a biblioteca do bliki.wiki em questão e por isso estou disponibilizando no meu repositório na internet. Para baixar essa lib do repositório basta registrar no pom.xml do projeto(entre as tags build e dependencies) o repositório com a seguinte entrada:
mawebhttp://www.maweb.com.br/mvn_repo
Com isso o arquivo pom.xml do pronto completo fica assim:
Após estas alterações os comandos do maven já irão funcionar corretamente como por exemplo:
mvn eclipse:eclipse - irá gerar arquivos de projeto para ser importado pelo eclipse. Se der algum erro tente rodar mvn eclipse:clean e então o mvn eclipse:eclipse
mvn package - gera um .war do projeto no diretório targets.
Outro dia precisei que as aplicações rodando em weblogic server utilizassem recursos de compactação Gzip para conteúdos de texto, html, css e javascript. O Gzip compacta estes recursos para transimtir pela internet e posteriormente o browser descompacta o que pode aumentar sensivelmente a performance percebida pelo usuário final da aplicação em diversos casos.
No ambiente em questão o weblogic está configurado para servir também o conteúdo estático e neste caso a solução padrão no mundo java é utilizar a configuração por Filtros.
Felizmente já existe um filtro Open Source disponibilizado para o weblogic para este fim e por isso basta configurarmos o pacote para utilizá-lo. Segue um passo-a-passo.
1) Baixar o .jar com as classes do filtro Gzip que vc preferir ou então escrever e gerar seu .jar com o filtro. Se preferir utilizar um filtro já escrito seguem links com posts e código fonte para tal. Links em inglês. blog do Markus Eisele ou blog do Nagesh Susarla. Se você preferir desenvolver o seu filtro de compactação Gzip pode se basear em artigos já escritos a respeito filtros, gzip e performance no On Java, no JavaWorld ou no Java Boutique, dentre outros.
2) O segundo passo é configurar o seu filtro no web.xml da apliação web que irá utilizar o Gzip, essa configuração deve variar um pouco depedendo do filtro que for ser utilizado conforme mencionado no passo 1, portanto segue um exemplo meramente ilustrativo abaixo:
Finalmente, para checar a compactação utilizo o web developer toolbar do firefox em Information > View Document Size mostra a compactação de cada recurso carregado em uma página. Ver exemplo nas 2 imagens abaixo(ilustrativo).
Outra possibilidade é utilizar o plugin do Apache para Weblogic Server e habilitar a configuração de compactação do Apache para recursos estáticos.
[]s
O weblogic server possibilita a administração de um domínio mesmo quando o servidor de administração estiver fora do ar através do Node Manager que já deve ter sido devidamente configurado para gerenciar o domínio que será administrado.
O Node Manager é um serviço do weblogic server que possibilita a adminsitração de vários servidores configurados em vários hardwares diferentes através de um único console de administração ou de scripts WLST.
Neste post vou mostrar um script que pode ser utilizado para conectar no nodemanager de uma máquina e enviar comandos para inicializar servidores previamente configurados em um determinado domínio administrado por este nodemanager. O script assim como o arquivo de propriedades está comentado e seu código segue abaixo com comentários em seguida:
from java.util import Properties
from java.io import FileInputStream
from java.io import File
#import thread
from string import split
#============DEFINICAO DE FUNCOES============
#funcao que carrega dados de arquivo de propriedades
def carregaArquivoPropriedades(nomeArquivo) :
print 'carregando propriedades do arquivo: ' + nomeArquivo
#arquivo de propriedades a ser carregado
myProps = Properties()
#carrega arquivo de propriedades
myProps.load(FileInputStream(File(nomeArquivo)))
return myProps
#função que recupera servidores especificados no arquivo de propriedades.
def listaServidores(arquivoPropriedades):
print 'selecionando servidores da lista de propriedades'
servidores = []
propriedades = arquivoPropriedades.propertyNames()
while propriedades.hasMoreElements():
#carrega os nomes de todas as chaves carregadas do arquivo de propriedades
chave = propriedades.nextElement()
#recupera tipo da chave para verificar se é um servidor se for adiciona no array de servidores.
elemento = split(chave, '_')
#checa se elemento carregado do arquivo de properties é um servidor e adiciona na lista de servidores
if elemento[0] == 'SERVIDOR':
servidores.append(chave)
#while que imprime lista de servidores recuperada
print '=======================AVISO================================================================'
print'LISTA DOS SERVIDORES A SEREM INICIALIZADOS'
for servidor in servidores:
print 'Servidor ==>> ' + arquivoPropriedades.get(servidor)
print '=======================AVISO================================================================'
return servidores
def inicializaInstancias():
usuario = arquivoPropriedades.get('USUARIO_ADM')
senha = arquivoPropriedades.get('USUARIO_ADM_SENHA')
ipNodeManager = arquivoPropriedades.get('NODEMANAGER_IP')
portaNodeManager = arquivoPropriedades.get('NODEMANAGER_PORT')
nomeDominio = arquivoPropriedades.get('DOMINIO_NOME')
diretorioDominio = arquivoPropriedades.get('DOMINIO_DIRETORIO')
print '\n================================================================================================'
print 'tentando conexao com o nodemanager...'
print 'usuario: ' + usuario
print 'ip Node Manager: ' + ipNodeManager
print 'porta Node Manager: ' + portaNodeManager
print 'Nome do dominio: ' + nomeDominio
print 'Diretorio do dominio no servidor: ' + diretorioDominio
print '================================================================================================'
nmConnect(usuario,senha, ipNodeManager, portaNodeManager, nomeDominio, diretorioDominio, 'plain', 'true')
for servidor in servidores:
print 'solicitando inicializacao do servidor ' + arquivoPropriedades.get(servidor)
nmStart(arquivoPropriedades.get(servidor), diretorioDominio)
#==========execucao (Main)========
arquivoPropriedades = carregaArquivoPropriedades('servidores.properties')
servidores = listaServidores(arquivoPropriedades)
inicializaInstancias()
O script carrega a lista de servidores de um arquivo de propriedades e inicializa cada um dos servidores declarados no arquivo. Abaixo um arquivo de propriedades de exmplo que pode ser utilizado com este script.
#colocar o IP e porta do nodemanger onde os servidores estão configurados. Caso houver
#necessidade de inicializar ou parar serviores em mais de um hardware o script deverá ser
#executado 1 vez para cada configuração de nodemanager e após feitos os devidos ajustes de ip e
#porta onde o nodemanager se encontra em execução.
NODEMANAGER_IP=localhost
NODEMANAGER_PORT=5559
#colocar o nome do diretório do domínio que será gerenciado pelo script.
DOMINIO_NOME=testescripts
#colocar o caminho completo do domínio que será gerenciado pelo script.
DOMINIO_DIRETORIO=/home/mmaia/weblogic10/domains/testescripts
#usuário e senha de administração deste domínio. Devem ser iguais aos do nodemanager configurados
#para gerenciamento deste domínio e armazenados no arquivo nm_password.properties do domínio.
USUARIO_ADM=weblogic
USUARIO_ADM_SENHA=weblogic
#lista de nomes das instancias a serem inicializadas ou paradas, deve seguir o padrao SERVIDOR_X=
#pode-se registrar quantas instânciasforem necessárias. As instâncias listadas devem estar
#configuradas no ambiente onde o nodemanager configurado está.
SERVIDOR_1=teste-1
SERVIDOR_2=teste-2
SERVIDOR_ADMIN=AdminServer
No primeiro post sobre o Open Flash Chart 2 eu mostrei como fazer um primeiro exemplo utilizando um html simples e um arquivo JSON para gerar um gráfico em Flash. Neste post vou demonstrar a utilização do JOFC2 que é uma API para utilização do OFC 2 com java. O arquivo open-flash-chart.swf já deve ter sido colocado na raiz do projeto web do appfuse conforme descrito no primeiro post sobre esse assunto.
2)Crie uma User librarie no struts com a biblioteca do JOFC e adicione como dependência do seu projeto do Appfuse. Para executar esse passo no eclipse vá em Window > Preferences vá em User libraries de Java e adicione uma nova librarie chamada Jofc2 e nesta librarie adicione o jar do Jofc e a dependência XStream conforme a imagem abaixo.
Não se esqueça de adicionar essa nova librarie como dependência no seu projeto do Appfuse, para isso clique com o botão direito do mouse sobre o nome do projeto no eclipse e depois properties , procure java build path e adicione a librarie como dependência no projeto.
3)Crie uma Action e registre no struts.xml
Para criar a action vá na estrutura do projeto sob a estrutura do projeto do appfuse src>main>java , selecione o diretório das actions e com botão direito do mouse selecione new>Class e crie uma action chamada JOFC2Action conforme o código mostrado abaixo(os imports foram omitidos para simplificar):
package br.com.maweb.webapp.action;
import...
public class JOFC2Action extends BaseAction {
private static final long serialVersionUID = 4486376620652216855L;
public String processaOFC() {
Chart chart = new Chart();
chart.setTitle(new Text("Java OFC test"));
chart.setBackgroundColour("#FFFFFF");
LineChart lc = new LineChart();
lc.setText("Text 1");
lc.addDots(new Dot(7, "#0000FF", 2, 2));
lc.addValues(5, 6, 7, 8, 7);
LineChart lc2 = new LineChart();
lc2.setColour("#000000");
lc2.setText("Text 2");
lc2.addDots(new Dot(2, "#FF0000", 2, 2));
lc2.addValues(1, 2);
BarChart bc3 = new BarChart(BarChart.Style.NORMAL);
// bc3.setAlpha(0.3f);
Bar b2 = new Bar(5.0);
Bar b3 = new Bar(6.0);
Bar b4 = new Bar(4.0);
bc3.addBars(b2, b3, b4);
chart.addElements(bc3, lc, lc2);
YAxis ya = new YAxis();
ya.setGridColour("#DDDEE1");
ya.setColour("#96A9C5");
ya.setOffset(false);
chart.setYAxis(ya);
XAxis xa = new XAxis();
xa.setGridColour("#DDDEE1");
xa.setColour("#96A9C5");
chart.setXAxis(xa);
chart.setFixedNumDecimalsForced(true);
chart.setDecimalSeparatorIsComma(true);
String grafico = chart.toString();
try {
grafico = URLEncoder.encode(grafico, "UTF-8");
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
getRequest().getSession().setAttribute("grafico", chart.toString());
return SUCCESS;
}
}
Esta Action do struts 2 faz a geração de um gráfico DEMO para utilizarmos no exemplo e coloca o resultado gerado que é um JSON na sessão com a chave grafico que será recuperada depois. Após gerar a action temos que registrá-la no struts.xml do projeto conforme trecho de código abaixo:
/jofc2.jsp
Isso fará que um acesso a url http://localhost:8080/jofc2.html execute a action e após isso irá direcionar para a página chamada jofc2.jsp que criaremos no próximo passo.
4)Crie uma página chamada jofc2.jsp. No projeto do eclipse sob a pasta src/main/webapp crie uma página chamada jofc2.jsp com o seguinte código(as tags html, head e script foram alteradas para compatibilidade com o post neste blog e vc deve corrigí-las antes de executar o exemplo):
Nesta página declaramos o elemento do Open Flash Chart e fazemos referência a uma página onde o json deve ser recuperado chamada json.jsp.
5)Crie uma página para colocar o JSON gerado chamada json.jsp . Crie uma página jsp com o nome json.jsp no mesmo diretório da página jofc2.jsp que irá recuperar a string JSON colocada pela action na sessão:
<%=session.getAttribute("grafico")%>
O código desta página é só esta linha mesmo. O interessante é que esta foi a única notação que funcionou para o Open Flash Chart, experimentei as notações do JSTL como c:out ou mesmo ${session.grafico} que imprimem EXATAMENTE a mesma String JSON e simplesmente não funciona. Acredito que seja alguma coisa no engine do JSTL do Jetty que cause a incompatibilidade.
6)Configure o projeto do Appfuse para não utilizar o decorator para a página do json. O projeto do Appfuse com struts 2 utiliza o Sitemesh para configurar as páginas, na página json.jsp não queremos que o template default seja utilizado pois queremos somente a String JSON para configuração do gráfico por isso deve-se acrescentar ao arquivo decorators.xml uma linha excluindo a página json.jsp da aplicação do template, segue código do arquivo decorators.xml.
7)Disponibilizar as libs do jofc para o maven: Registrar repositório e incluir dependências no pom.xml do projeto. Como ainda não encontrei um repositório público do maven com as bibliotecas necessárias para rodar o JOFC 2 disponibilizei no meu servidor da maweb. Por isso para poder baixar as libs do projeto e a dependência temos que registrar no pom.xml do projeto onde estas libs podem ser encontradas. Faremos isso declarando um novo repositório que irá apontar para www.maweb.com.br e registrando as libs que precisamos. Edite o pom.xml adicionando o trecho de código a seguir do repositório e das 2 libraries necessárias respectivamente:
8)Disponibilizar na sua aplicação o javascript do JOFC (swfobject.js). O approach que utilizo neste tutorial depende de um javascript chamado swfobjec.js que vem no pacote do download do JOFC 2 e portanto copie este arquivo para o mesmo diretório das páginas criadas acima no projeto. Pronto, finalmente estamos prontos para rodar o exemplo para isso abra um console do seu sistema operacional e navegue para o diretório raiz do seu projeto, onde tem o pom.xml e rode o jetty utilizando o comando:
mvn jetty:run
Depois é só acessar a aplicação passando pela action conforme descrito no último passo abaixo.
9) Acessar a aplicação utilizando a url http://localhost:8080/jofc2.html , você deverá ver uma página com um gráfico simples renderizado conforme imagem mostrada abaixo:
Este é um gráfico de demostração para atingir o objetivo deste post, em um ambiente de projeto profissional pode-se utilizar um interceptor do struts para gerar o JSON o que facilitará quando precisarmos ter mais de um gráfico em uma página. Vários outros tipos de gráficos mais complexos podem ser gerados com esta API conforme mostrado nas páginas oficiais do projeto com exemplos em PHP neste link.
Escrevi este post com o intuito de acelerar a criação de projetos do Appfuse que fossem funcionais no ambiente eclipse. O Appfuse é um excelente projeto que ajuda na integração de vários projetos opent source e com isso acelera o início do ciclo de desenvolvimento. Para criar um projeto com Appfuse é utilizado o maven e portanto para executar o script deste post o maven deve estar configurado no seu ambiente e deve ter um JDK 1.5 ou superior configurado.
Após alguma experiência com o Appfuse cheguei a um padrão na criação de projetos e portanto para acelerar o procedimento consolidei em um script.
O script cria um projeto de testes e para mudar o pacote e nome do projeto criado basta alguma edição no script. O script está bem documentado e é auto-explicativo. É um script que foi testado no ambiente linux com java 6 e para reutilizá-lo basta uma rápida adaptação para utilizar o JDK de sua preferência, o JDK deve ser 1.5 ou superior. Segue o script.
PATH=/home/mmaia/tools/jdk1.6.0_13/bin:${PATH}
export PATH
echo ${PATH}
#cria o projeto, o maven deve estar configurado no ambiente para funcionar.
mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-struts -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=br.com.maweb -DartifactId=TestesJOFC2
#entra no diretório do projeto criado
cd TestesJOFC2
#baixa o código do core do appfuse para possibilitar evolução no seu projeto posteriormente.
mvn appfuse:full-source
#baixa todas as dependências para o repositório do maven executa todos os testes unitários do projeto.
mvn
#baixa parte web do projeto
mvn war:inplace
#remove no linux libraries para rodar aplicativo com container jetty de forma expandida o que facilita durante o desenvolvimento por refletir mais diretamente as alterações.
rm -r src/main/webapp/WEB-INF/lib/
rm -r src/main/webapp/WEB-INF/classes/struts.xml
#configura projeto para ser importado pelo eclipse.
mvn eclipse:eclipse
Após a execução do script o projeto criado pode ser importado como um projeto do eclipse normalmente. Abra o pom.xml do projeto criado e configure a os dados de usuário e senha da base de dados que irá ser utilizada no projeto sendo a default a mysql com usuário root e sem senha, se tiver dificuldades veja este post. Após configurar a base de dados então em um comando de linha para testar basta inicializar o jetty utilizado no desenvolvimento com o seguinte comando:
mvn jetty:run
Para ver o projeto acesse com o browser http://localhost:8080 e utilize usuário/senha = user/user.
Bem se o script não foi alterado teremos um projeto chamado TestesJOFC2 que é um projeto de testes para uma librie de geração de gráficos chamada Open Flash Chart que descrevo em outro post.
Durante o desenvolvimento de um projeto pessoal sempre tive um sentimento de que os gráficos que estava utilizando que são gerados utilizando a Google chart api que é excelente mas por se basear em imagem não fornece o nível de gráficos que eu desejo para o meu projeto. Após alguma pesquisa encontrei a API Open Flash Chart 2 que pelas minhas pesquisas apresenta funcionalidades muito mais próxima das que eu desejo para o projeto. Este post tem por objetivo mostrar a configuração necessária e também minhas primeiras impressões na utilização da API Open Flash Chart 2 em meu projeto.
O projeto que estou desenvolvendo e onde irei testar a integração desta API utiliza a estrutura fornecida pelo Appfuse com Struts 2.
Na própria página do projeto existe uma referência a uma librarie java que pode ser utilizada para integrar o Open Flash Chart em um projeto J2EE, que é o meu caso, decidi então utilizar a librarie chamada jofc2 no projeto por considerar que é a que está mais evoluída. Neste primeiro post sobre o assunto vou demonstrar a configuração básica do OFC com um projeto do AAFuse utilizando HTML simples e um arquivo JSON seguindo o exemplo 1 dos tutoriais do JOFC2.
Como esta API é em flash seu funcionamento se baseia em baixar um arquivo flash já pronto e depois configurá-lo utilizando Json. A API jofc2 que irei utilizar permite que fiquemos abstraídos do JSon utilizando somente java para configurar os gráficos.
Para iniciar os testes o primeiro passo é criar um projeto funcional do appfuse. Após o projeto ser criado vamos executar um primeiro exemplo simples de gráfico OFC utilizando html puro e json.
Para isso copie para a raiz web do seu projeto do appfuse criado o arquivo do pacote OFC chamado open-flash-chart.swf e crie os arquivos chart.htm e data.json na estrutura do projeto e copie o arquivo open-flash-chart.swf colocando-os sob o diretório src/main/webapp conforme mostrado na imagem abaixo:
Segue código a ser inserido no arquivo chart.htm(as tags de abertura e fechamento de html e body do código foram omitidas para compatibilidade de postagem com o blogspot e devem ser corrigidas antes de rodar o exemplo) :
Após ter configurado estes 3 arquivos para ver o seu primeiro gráfico OFC funcionando execute o projeto do Appfuse gerado com o comando mvn jetty:run e acesse a url: http://localhost:8080/chart.htm?ofc=data.json
Se tudo tiver sido feito corretamente um gráfico como o mostrado na imagem abaixo deverá ser renderizado. Em um próximo post irei detalhar como utilizar a biblioteca JOFC para renderizar os gráficos utilizando struts2 e jsp.
Impressionado com o google wave resolvi dar uma olhada no Google Web Toolkit que é o framework open source de um projeto da Google que é utilizado para o desenvolvimento do wave. Nunca tinha avalido o GWT seriamente e resolvi então dar uma boa olhada pois na apresentação do wave o desenvolvedor citou a facilidade de reutilização de código também para celulares e como ando estudando desenvolvimento de devices achei interessante dar uma boa olhada. A seguir posto minhas primeiras impressões sobre o GWT e também um rápido passo a passo para utilizá-lo pela primeira vez.
A primeira boa notícia para mim foi que o GWT abstrai toda a construção da aplicação para browsers em linguagem java, no meu caso que a quase 10 anos sempre apostei no java isso soou bastante promissor.
Outra coisa agradável foi a primeira impressão que tive com a documentação do kit que é bastante completa e simples, direto ao ponto, ou seja, no meu ponto de vista a melhor forma. Não gosto de ficar lendo grandes introduções e teorias sobre os frameworks que estou avaliando, prefiro ir direto ao ponto e desenvolver alguma coisa simples para aí sim aprofundar, se for o caso, e então utilizar em algum projeto real.
Finalmente a melhor das notícias é que já existe um plugin do eclipse para o GWT o que possibilita que possamos fazer alguns testes com ele muito fácil e rapidamente. Vamos então ao passo a passo:
1) Baixar o plugin do eclipse utilizando a url de download do update site:
Para eclipse Europa: http://dl.google.com/eclipse/plugin/3.3
Para eclipse Ganymede: http://dl.google.com/eclipse/plugin/3.4
2) Reiniciar o eclipse.
3) Criar um projeto utilizando o GWT plugin do eclipse.
Uma vez que o plugin estiver instalado, para criar um projeto utilize o menu de criação de aplicação web normalmente: File > New > Web Application Project. Se o plugin estiver corretamente instalado este será agora um projeto habilitado para o GWT.
4) Executar o projeto. Para executar o projeto no ambiente local, basta executar o projeto como uma aplicação web tradicional.
Bem esta foi uma breve introdução do que vi até o momento sobre o GWT, irei agora desenvolver algum pequeno protótipo funcional de aplicação para realizar alguns testes e posteriormente posto minhas impressões. Seguem alguns links úteis para quem quiser saber mais.
Dica final: A primeira vez que você for rodar uma aplicação utilizando o plugin com linux(meu caso) pode ocorrer o seguinte erro:
** Unable to load Mozilla for hosted mode **
java.lang.UnsatisfiedLinkError: .../mozilla-1.7.12/libxpcom.so: libstdc++.so.5:
cannot open shared object file: No such file or directory ...
Isso ocorre porque as novas versões do Ubuntu não trazem essa lib por defaul instalada. Para resolver o problema abra um console e baixe a lib com o comando:
O cluster de servidores de aplicação nos dá um certo conforto em relação à disponibilidade de nossas aplicações corporativas hoje em dia. O ambiente de tolerância a falhas e redundância proporcionado pelos clusters possibilita, dentre outras coisas: manutenção de ambiente de produção em tempo real, agregar poder de processamento a uma aplicação crítica, certa estabilidade em caso de falhas de aplicação, dentre várias outras funcionalidades extremamente importantes nos ambientes corporativos e competitivos da internet de hoje em dia.
Uma das exceções neste ambiente é quando a arquitetura de uma aplicação foi construída utilizando como base um Singleton que neste caso não pode ser distribuído para todo o cluster pois traria inconsistência no funcionamento da aplicação.
No weblogic server utilizando o serviço de migração automática de um cluster conseguimos ter uma boa opção para este tipo de serviço implementando o que é chamado de Serviço de Singleton(Singleton Services). Esta implementação nos garante a migração automática do serviço disponibilizado para um outro nó(servidor) do cluster em caso de falhas no servidor onde o Sigleton está sendo executado.
Como funciona?
No weblogic existe um componente chamado "Singleton Master" que é um componente que monitora os serviços que podem ser migrados automaticamente em caso de falha do nó do cluster onde um Singleton esteja atendendo requisições dos clientes e então ele controla o serviço de singloton para inicializar em um outro nó disponível do cluster. Por padrão o Singleton Master considera todos os servidores disponíveis em um cluster como candidatos para migração de um Singleton Service que venha a falhar, entretando uma lista pode ser especificada se for o caso. Se o Singleton Master tentar ativar o serviço que falhou em todos os nós da lista ou do cluster e falhar, o serviço ficará desativado.
Como é a implementação de um Singleton Service no Weblogic?
Para implementar a classe do Singleton deve implementar uma interface do Weblogic chamada weblogic.cluster.singleton.SingletonService e prover a implementação de 2 métodos para alocar e desalocar os recursos necessários ao Singleton respectivamente: activate() e deactivate() .
Feito isso basta escolher uma forma de registrar seu Singleton service com o Singleton Master do cluster que pode ser feito via Admin Console ou configurando no weblogic-application.xml o Singleton service(tem que ser um componente .ear).
Para configurar via Admin console, selecione o cluster e depois clique em Singleton Services, lá pode-se registrar a classe do Singleton Services diretamente. Para que isso funcione esta classe deverá ter sido disponibilizada no classpath dos servidores candidatos a rodarem o serviço.
Bem, é isso, o gerenciamento da disponibilização do serviço é feita então automaticamente pelo cluster do Oracle Weblogic Server que estiver sendo utilizado.
Motivado por um post no javaranch fiz este script simples que checa status e saúde de uma aplicação em um servidor weblogic.
O script é bem simples e por isso estou omitindo maiores explicações. Segue o script.
#variable definitions================
username='weblogic'
password='weblogic'
urladmin='t3://localhost:7001'
appName='applicationName'
serverName='serverName'
#end variable definitions============
#connects to admin server
connect(username, password, urladmin)
cd('domainRuntime:/AppRuntimeStateRuntime/AppRuntimeStateRuntime')
#get intended state for application
intendedState = cmo.getIntendedState(appName)
print 'Intended state for app ' + intendedState
#get current real state for app in specific server
currentState = cmo.getCurrentState(appName, serverName)
print 'Current state in server '+ serverName + ' ==>> ' + currentState
cd('domainRuntime:/ServerRuntimes/'+ serverName +'/ApplicationRuntimes/'+appName)
#shows app attributes including current health.
print 'Current information for app ' + appName + ' in server ' + serverName + ' ==>> ' + ls('a')
Neste post irei mostrar o passo a passo para fazer a integração do kit de desenvolvimento nokia para plataforma S60 com Eclipse Ganymede.
Atualmente utilizo para desenvolvimento JME a seguinte configuração:
Com esta configuração e após deixar no meu projeto somente as APIs compatíveis para a plataforma S60 do meu celular(MIDP 2.0 e CLDC1.1) eu fui capaz de baixar e rodar minha aplicação no device, mas ainda com alguns erros e portanto o emulador da nokia se tornou essencial para que eu possa evoluir meu projeto.
Para instalar o kit é necessário também ter instalado o kit de desenvolvimento da nokia chamado Carbide.J que pode ser baixado aqui
1) Instalar o Carbide.j 1.5
Este passo é bem simples para isso após baixar o arquivo .zip do Carbide.j descompacte em uma pasta e execute o setup.exe o processo de instalação é simples, basta seguir as instruções selecionando a versão para Eclipse no momento apropriado e apontando para o diretório de instalação do seu eclipse quando solicitado.
2) Configurar o debugger do eclipse
Neste passo no menu do eclipse vá em Windows > Preferences > Java > Debug . Nesta tela desmarque todas as opções de suspend debug e aumente o tempo de "Debug Timeout" para 50000 ms conforme orientação da nokia. Isto é necessário para que o timeout default configurado não impeça a execução do emulador.(ver imagem)
3) Adicionar o emulador do S60 ao eclipse.
Este passo foi o mais problemático no eclipse estranhamente tive que instalar novamente o Carbide.j para que o menu do eclipse apresentasse a opção correta(não reiniciei na segunda instalação). Para executar esse passo no menu do eclipse primeiro selecione um projeto JME na perspectiva java e depois ir em Tools > Carbide.j > Configure Emulators . Clique em add e selecione o diretorio de instalação do Kit de desenvolvimento para S60 e depois que ele aparecer na lista de Emuladores selecione a entrada dele e clique no botão Set as Default. Pronto o emulador está pronto para ser utilizado.
Para utilizá-lo selecione Tools > Carbide.j > Start Emulators
Na tela que irá abrir em Application aponte para um .jad de exemplo que vem com o SDK da plataforma S60 em %S60_HOME%\devices\S60_3rd_MIDP_SDK_FP1\S60examples\helloworldplus\bin e clique em Emulate. A aplicação deve aparecer após algum tempo. Tenha paciência pois isso pode levar alguns minutos dependendo da configuração da sua máquina.
No final consegui rodar minha aplicação no emulador mas fiquei um pouco decepcionado com a lentidão desse ambiente.
[]s
Para iniciar os testes com Java ME de minha aplicação estou utilizando um celular Nokia n96 que utiliza a plataforma para smartfones S60
Inicialmente tentei fazer upload direto da minha aplicação JME para meu servidor transferindo o .jar e o .jad e acessando pelo celular. A aplicação foi encontrada e eu confirmei a instalação mas ao terminar o aparelho informou que a aplicação não estava com a especificação correta para o device e por isso eu pesquisei até encontrar a plataforma de desenvolvimento fornecida pela nokia e irei começar a estudá-la.
Neste post irei descrever um guia rápido para instalação da plataforma de desenvolvimento provida pela Nokia para S60 em sistema operacional Windows XP.
Este post mostra a criação e configuração de machine, servidores e um cluster utilizando o console de administração do domínio criado na parte 2 do tutorial. Par ver todos os posts relacionados a este tutorial clique no Título deste post!
Aí vai uma dica rapida. Para mostrar a data de hoje formatada no jsp uma maneira simples, rápida e que não exige importação é utilizar o velho scriplet:
Data de Hoje: < %= new java.text.SimpleDateFormat("dd/MM/yyyy").format(new java.util.Date())%>
Quando quiser mostrar uma data que está armazenada em um objeto armazenado no request ou em algum objeto de action do struts ou jsf pode-se utilizar jstl para formatar a variável. No exemplo abaixo existe um objeto user armazenado no request que tem um atributo dataCadastroSistema e quero mostrar esta data. O que faço é armazenar a variável utilizando c:set em uma variável chamada dataCadastro e depois faço a formatação, facilitando o entendimento. Você poderia recuperar a data do request direto na tag de formatação fmt se desejar.
Esta é uma questão frequente nos fórums de weblogic e por isso estou postando aqui.
É comum que uma aplicação web precise acessar conteúdo estático existente em algum diretório compartilhado em servidor, disco de storage externo ou até mesmo em um diretório no Sistema operacional em ambientes não clusterizados.
No weblogic tem uma maneira bem simples de resolver este problema para isso utiliza-se uma tag no arquivo weblogic.xml que irá apontar para um diretório especificado e criará um url-pattern de acesso ao conteúdo desejado.
Para ilustrar o exemplo, suponhamos que seja desejado compartilhar o conteúdo estático que está disponível no caminho: /var/docs/weblogic/estatico no servidor onde o weblogic está instalado. Imagine que exista um arquivo chamado meuPdf.pdf que está diretamente neste diretório, para acessar este arquivo queremos que uma url direta aponte para o pdf em questão. Para isso deve-se configurar a tag virtual-directory-mapping, local-path e url-pattern no weblogic.xml:
/var/docs/weblogic/estatico/*
Isso irá permitir que uma url como: http://seudominio.com/estatico/meuPdf.pdf encontre corretamente o arquivo desejado. Se houver pastas no diretório basta apendar a pasta depois do url-pattern definido para acessar corretamente o conteúdo.
Esta dica possibilita também que conteúdo estático seja disponibilizado e acessado corretamente fora do pacote dinâmico no weblogic, tornando o pacote dinâmico bem menor facilitando as atualizações.
Na primeira parte deste tutorial mostrei a instalação do Oracle Weblogic Server no windows. Neste post irei mostrar a criação de um domínio que será utilizado para criação de um cluster nos próximos posts deste tutorial.
Um domínio no weblogic server é utilizado para controlar um conjunto de servidores realcionados. Tipicamente um domínio tem 1 Administration server e N servidores gerenciados por ele. Tenha em mente que um domínio do weblogic server pode se extender por vários hardwares e não tem relaçao com o conceito de domínio utilizado por sistemas operacionais. A definição direta é: Um domínio é um conjunto de servidores gerenciados por um Administration Server. Inicialmente irei utilizar apenas o meu desktop no tutorial mas este domínio pode posteriormente ser facilmente adequado para outros hardwares(Escalabilidade Horizontal).
Outro dia me deparei com um questionamento no fórum de discussão sobre como conseguir retirar os thread dumps do Servidor de aplicações, Oracle Weblogic, em momento oportuno, ou seja, quando o ambiente estiver passando por um momento de contingência. A discussão do problema pode ser vista detalhadamente no fórum do javaranch no link: http://www.coderanch.com/t/427054/BEA-Weblogic/Issue-with-WeblogicServer
Devido a este problema decidi escrever um artigo mostrando como podemos utilizar a linguagem de scripts do Weblogic Server, Weblogic Scripting Tool(WLST), para fazer monitoramento de servidores. Um ponto importante nestes script é que ele permite inclusive que este monitoramente seja feito de forma independente do Admin Server, pois neste caso, o script mostra conexão direta com servidores gerenciados de um domínio. Para escrevê-lo estou utilizando WLST que por sua vez utiliza linguagem Jython e é padrão para configuração do Oracle Weblogic.
O script:
O script demonstrado aqui é bem simples e o que ele faz basicamente é:
1) Carregar informações de um arquivo de propriedades.
2) Tenta conectar com cada um dos servidores da lista de servidores configurada no arquivo de propriedades.
3) Verifica status do servidor e caso o servidor estiver com um número maior que o definido de threads com delay na resposta gera um thread dump do servidor para posterior análise.
Abaixo segue o código do script comentado e logo em seguida um exemplo de arquivo de propriedades que pode ser utilizado como template.
from java.util import Properties
from java.io import FileInputStream
from java.io import File
#============DEFINICAO DE FUNCOES============
#funcao que carrega dados de arquivo de propriedades
def carregaArquivoPropriedades(nomeArquivo) :
print 'carregando propriedades do arquivo: ' + nomeArquivo
#arquivo de propriedades a ser carregado
localizacaoArquivoPropriedadesConfiguracao = nomeArquivo
myProps = Properties()
#carrega arquivo de propriedades
myProps.load(FileInputStream(File(localizacaoArquivoPropriedadesConfiguracao)))
return myProps
#funcao que retorna lista de todos os servidores configurados para este domínio.
def getServidoresDominio():
print 'executando funcao getServidoresDominio']
domainConfig()
servidores = cmo.getServers()
return servidores
#funcao que pega lista de servidores como parametro e verifica o status de cada um deles.
def mostraStatusServidores(servidores):
print '=======================STATUS dos servidores do domínio==============='
domainRuntime()
for servidor in servidores:
try:
cd('/ServerRuntimes/' + servidor.getName())
#ls()
print servidor.getName() + ': ' + get('State')
except WLSTException,e:
servidoresNaoAcessiveis.append(servidor)
servidoresAlerta = []
#testa novamente servidores que não estava acessíveis para ter certeza
for servidor in servidoresNaoAcessiveis :
try:
cd('/ServerRuntimes/' + servidor.getName())
#ls()
print servidor.getName() + ': ' + get('State')
except WLSTException,e:
servidoresAlerta.append(servidor)
if len(servidoresAlerta) > 0 :
print 'ALERTA == ALERTA == ALERTA == ALERTA == ALERTA == ALERTA =='
print 'Os seguintes servidores estão inacessíveis para monitoração, favor checar!'
for servidor in servidoresAlerta :
print servidor.getName()
#faz checagem de memória nos servidores do domínio especificado.
def listaConfiguracoesMemoriaServidoresDomino():
servidoresComBaixoHeapMemoria = []
for servidor in servidores:
try:
cd("domainRuntime:/ServerRuntimes/" + servidor.getName() + "/JVMRuntime/" +servidor.getName())
heapSizeMax = cmo.getHeapSizeMax()/1048576
heapMemoriaLivre = cmo.getHeapFreeCurrent()/1048576
heapMemoriaLivrePercentagem = cmo.getHeapFreePercent()
#adiciona na lista de servidores com pouca memoria se servidor tiver menos de 2% de memória livre
if heapMemoriaLivrePercentagem < 2 :
servidoresComBaixoHeapMemoria.append(servidor)
#memoriaMB = memoria/1048576 #transforma os bytes em MB para mostrar
print '\n================================================================='
print "O servidor " + servidor.getName() + " esta com :"
print 'Memoria total alocada(MB): ' + str(heapSizeMax)
print 'Memoria total disponivel(MB): ' + str(heapMemoriaLivre)
print 'Memoria livre(%): ' + str(heapMemoriaLivrePercentagem)
except WLSTException,e:
print 'AVISO: O servidor ' + servidor.getName() + ' nao esta acessivel atraves do admin server'
#faz novo teste de heap de memória e caso continuem com pouca memória disponível, mostra ALERTA para observação do servidor.
for servidor in servidoresComBaixoHeapMemoria :
try:
cd("domainRuntime:/ServerRuntimes/" + servidor.getName() + "/JVMRuntime/" +servidor.getName())
except WLSTException,e:
print 'AVISO: O servidor ' + servidor.getName() + ' nao esta acessivel atraves do admin server'
heapMemoriaLivrePercentagem = cmo.getHeapFreePercent()
#adiciona na lista de servidores com pouca memoria se servidor tiver menos de 2% de memória livre
if heapMemoriaLivrePercentagem < 2 :
print 'ALERTA == ALERTA == ALERTA == ALERTA == ALE RTA == ALERTA =='
print 'O servidor ' + servidor.getName() + ' está com heap de memória < que 2% e deve ser observado!'
#faz checagem de threads dos servidores do domínio
def checaThreadsServidoresDominio() :
servidoresComThreadsProblematicas = []
for servidor in servidores :
try:
cd("domainRuntime:/ServerRuntimes/" + servidor.getName() + "/ServerChannelRuntimes/DefaultSecure[https]")
numeroConexoes = cmo.getConnectionsCount()
print '==============================================='
print 'Dados do servidor ' + servidor.getName() + ': '
print 'Conexoes https: ' + str(numeroConexoes)
cd('domainRuntime:/ServerRuntimes/' + servidor.getName() + '/ExecuteQueueRuntimes/weblogic.socket.Muxer')
fila = cmo.getPendingRequestCurrentCount()
print 'Requisicoes de usuarios pendentes: ' + str(fila)
cd('domainRuntime:/ServerRuntimes/' + servidor.getName() + '/ThreadPoolRuntime/ThreadPoolRuntime')
hoggingThread = cmo.getHoggingThreadCount()
print 'Quantidade de threads com status hogging: ' + str(hoggingThread)
print '===============================================\n'
except WLSTException,e:
print 'Erro servidor não acessivel para ServerRuntimes ==>> ' + servidor.getName()
#faz health check nos pools de conexao do ambiente.
def checaPoolsConexoes() :
domainConfig()
#recupera lista de pools de conexões configuradas no domínio.
connectionPools = cmo.getJDBCSystemResources()
for pool in connectionPools :
print pool.getName()
cd('domainConfig:/JDBCSystemResources/' +pool.getName()+ '/JDBCResource/' +pool.getName()+ '/JDBCConnectionPoolParams/' + pool.getName())
print '==============================================='
print 'Dados do pool: ' + pool.getName()
capacidadeInicialPool = cmo.getInitialCapacity()
capacidadeMaximaPool = cmo.getMaxCapacity()
print 'Capacidade maxima do pool: ' + str(capacidadeMaximaPool)
cd('domainConfig:/JDBCSystemResources/' + pool.getName())
targetServers = cmo.getTargets()
print 'targets do pool'
for targetServer in targetServers :
print targetServer.getName()
#=================FIM DEFINICAO DE FUNCOES======================
propriedades = carregaArquivoPropriedades('config.properties')
username = propriedades.get('username')
password = propriedades.get('password')
url = propriedades.get('url')
connect(username, password, url)
#lista para armazenar servidores não acessíveis através do admin server.
servidoresNaoAcessiveis = []
servidores = getServidoresDominio()
mostraStatusServidores(servidores)
listaConfiguracoesMemoriaServidoresDomino()
checaThreadsServidoresDominio()
checaPoolsConexoes()
disconnect()
exit()
E o arquivo de propriedades de exemplo:
#este arquivo de propriedades é utilizado para configurar os
#servidores em um ambiente. Todas as chaves devem ter o formato
#do nome utilizando sempre _ (underscore) pois é o que define a
#busca dos nomes dos elementos e separa durante a configuarção
#no script criaInstancias.py
USUARIO_ADMIN=user
SENHA_ADMIN=pwd
PORTA_HTTPS_SERVIDORES=443
#parametro que configura com que quantidade de threads com delay o thread dump deve ser tirado para o servidor.
PARAMETRO_THREAD_DUMP=10
#Dados dos servidores a serem monitorados pelo script
SERVIDOR_1=server1
IP_SERVIDOR_1=xxxxxx
SERVIDOR_2=server2
IP_SERVIDOR_2=xxxxxxx
SERVIDOR_3=server3
IP_SERVIDOR_3=xxxxxx
SERVIDOR_4=server4
IP_SERVIDOR_4=xxxxxx
# .... you may add as many servers as you want here...
Para este script ficar realmente funcional eu programaria para que ele ficasse conectado com os servidores por um período definido em ciclos e que verificasse o status de cada um de tempos em tempos(3 em 3min por exemplo). E caso o servidor apresentasse algum problema considerável dispararia uma rotina que seria responsável por tirar thread dumps com intervalo de cerca de 20s entre um e outro por um período de 2 min. Os thread dumps retirados seriam de extrema utilidade para definir qual o real problema com o ambiente.
Fiquei algum tempo sem postar código fonte no blog pois como um blogueiro recente ainda não tinha conhecimento de como fazer para formatar o código fonte de uma maneira aceitável nos posts.
Bem, como este é um blog técnico ficou impossível continuar dessa forma e portanto hoje resolvi pesquisar uma forma de fazer formatação de códigos fonte para postagens no blog. Pesquisando um pouco decidi primeiramente experimentar mais um produdo hospedado no Google code chamado SyntaxHighlighter http://code.google.com/p/syntaxhighlighter/ . A última versão(quei irei tratar neste artigo) migrou para http://alexgorbatchev.com/wiki/SyntaxHighlighter
Minha maior curiosidade é ver como uma linguagem como Jython, que uso muito no weblogic e tenho alguns posts aqui, vai ficar formatada imagino que java deve ficar bem bacana por ser mais comum.
Segue um passo-a-passo do que fiz para fazê-lo funcionar e alguns links de postagens deste blog já formatadas com este utilitário.
O pacote contém um conjunto de javascript + css para formatação dos códigos.
Este conjunto deve ser disponibilizado na web para que possa ser acessado e essa foi minha primeira dificuldade, já estava pensando em fazer o upload para o ambiente que tenho contratado na locaweb(que por sinal é um excelente Hosting, não conheço melhor no Brasil) quando pesquisando a documentação do produto encontrei este link: http://alexgorbatchev.com/wiki/SyntaxHighlighter:Hosting
O criador do produto disponibiliza um repositório na web para acesso ao css e javascript e portanto vou testá-lo, se for o caso e eu sentir problemas de performance aí sim vou utilizar a Locaweb. Para utilizar o repositório disponibilizado nem havia necessidade de baixar o pacote!!!
O padrão para utilizar o hosting do autor, conforme documentação é: http://alexgorbatchev.com/pub/sh/[VERSION] e todas as versões disponíveis podem ser encontradas no link: http://alexgorbatchev.com/pub/sh/
Para utilizar o formatador o primeiro passo é declarar nas postagens desejadas o seguinte trecho de código que deve ser inserido no template de página no painel de administração do seu blog . No caso do blogger ir em Layout > Editar Html e colocar o javascript entre dentro da tag head do template, sugiro colocar imediatamente antes do fechamento da tag /head> depois salvar . (Eliminei tag de abertura html pois estava tendo problemas para mostrar!!! Alguém tem uma dica???):
Importante lembrar, e o autor do produto cita isso, que os caracteres de tag html e xml devem ser corretamente substituídos:
< por < > por > (ok.. ok.. esse não é obrigatório mas é uma boa prática).
Outra coisa é que se for usar o repositório disponibilizado deve-se mudar as referências passando o caminho completo, ex:
link type="text/css" rel="stylesheet" href="/styles/shCore.css">
Fica para versão 2.0.296:
link type="text/css" rel="stylesheet" href="http://alexgorbatchev.com/pub/sh/2.0.296/styles/shCore.css">
Lembrem-se que retirei a tag de abertura <
e assim segue para todas as referências.
Feito isso deve-se usar tags pre de html para formatar os códigos desejados e definir o que o autor chama de Brush relacionando ao padrão de fontes que está sendo formatado (java, javascript, etc).
Ver lista completa em: http://alexgorbatchev.com/wiki/SyntaxHighlighter:Brushes
Exemplo formatação javascript:
pre class="brush: js">alert("Hello world")/pre>
Um link em que já utilizo o recurso como referência:
P.S - Para cada brush que você decidir utilizar tem um javascript diferente que deve ser carregado.
P.S2 - Implementei em todo o blog a formatação de código. Deu um trabalho considerável(umas 4 horas para revisar cerca de 30 posts, ainda bem que sou blogueiro mirim ainda!!!!) pois tive que desabilitar a quebra automática de linha em Configurações > Formatação > Converter quebras de linha tive que colocar não pois caso contrário a ferramenta de edição deste blogger colocava automáticamente quebras de linha(br) nos códigos!!!
[]s
Recentemente um problema simples me tomou algumas horas de pesquisa e o problema, como usual, era simples de ser resolvido.
Utilizando Struts 2 do Appfuse para desenvolvimento de uma aplicação quando colocava um tooltip no formulário percebia um erro mostrado pelo firebug no firefox o tooltip era:
E o erro mostrado pelo firebug:
dojo is not defined:dojo.requ...);dojo.require("dojo.fx.html");
Fiz uma postagem na lista de discussão do appfuse em :
http://www.nabble.com/Using-struts-2-tooltip-causes-error!-td22669446s2369.html
E a solução do problema foi bem simples e envolve 2 passos:
1) Mudar a extensão do mapeamento do struts 2 de .html que é o default do appfuse pois isso causa conflito com dojo. (Esse passo eu já havia feito no meu projeto).
2) Adicionar a tag s:head do struts ao head html da página.
O problema foi resolvido, no meu caso, só com a s:head adicionada. Bem simples e me tomou um tempo considerável.
[]s
Este final de semana instalei o Ubuntu 8.10 no meu desktop para utilizar como ambiente de trabalho e desenvolvimento de software. Durante a instalação encontrei algumas dificuldades básicas que me tomaram algum tempo e por isso segue aqui algumas dicas e links de sites de como eu resolvi tais problemas para futura referência.
Instalação do Mysql, Mysql Admin Tools e Maven - A melhor forma de instalar o Mysql que encontrei foi utilizando a ferramenta Synaptic Package Manager(System > Administration > Synaptic Package Manager). Basta procurar por Mysql na busca da ferramenta, selecionar o que deseja instalar, e pronto, bem prático. Já para instalar o maven basta abrir um console e digitar sudo apt-get install maven2 aguarde os pacotes e dependências serem baixados e instalados configure o caminho para seu repositório em : /usr/share/maven2/conf/settings.xml e pronto o Maven está pronto para usar. Veja o vídeo ilustrativo da instalação do maven em: http://www.screencast.com/t/eeP2P8jws3
Configuração do Mysql - Um problema que senti assim que tentei utilizar o mysql é que não conseguia fazer conexão das ferramentas de administração. Isso acontece porque por default ele é habilitado para escutar conexões somente no localhost(127.0.0.1). Para mudar isso editar o arquivo: /etc/mysql/my.cnf e comentar a linha onde aparece: bind-address:127.0.0.1
Depois reiniciar o mysql com o comando: mysql restart
Habilitar efeitos 3D no Ubuntu - Por último uma coisa opcional mas bem legal é a instalação do pacote de efeitos de Desktop no Ubuntu o que vai dar visual mais legal e efeitos 3D(cubo) no O.S . Para fazer a instalação é bem fácil, utilizando o Synaptic Package Manger basta procurar por compizconfig-settings-manager e depois utilizar o menu do Ubuntu em System> Preferences> ConpizConfig Settings Manager para acessar o painel de configurações de efeitos, são vários, bem legal!
Assim que instalamos o Ubuntu e começamos a baixar os pacotes de programas para utilizar com ele nos deparamos com a necessidade de instalar pacotes no formato RPM pois alguns programas ainda disponibilizam somente pacotes com esta extensão que não é imediatamente reconhecida e executada pelo Ubuntu.
Por isso segue uma lista com instruções rápidas de execução de arquivos RPM no Ubuntu.
Primeiramente tem que instalar o Alien que é utilizado para conversão de formatos de arquivo no linux:
Quando formato o computador ou instalo um novo sistema operacional(Neste momento estou instalando Ubunto 8.10 para trabalhar no desktop em casa) para iniciar o meu trabalho é sempre chato ficar procurando os links para baixar tudo o que é necessário e útil para o dia a dia.
Atualmente utilizo o Appfuse para desenvolvimento e portanto a lista contém o necessário para utilizá-lo além de outras ferramentas úteis.
É bem desagradável quando só percebemos que precisamos de um determinado plugin do eclipse ou ferramenta indispensável quando efetivamente precisamos dela e percebemos que ainda temos que baixar, configurar, etc. Por isso estou colocando aqui uma lista de todas as principais ferramentas e plugins que utilizo para trabalhar para futuramente servir de ponto de partida para a montagem de um novo ambiente de trabalho.
No Ubuntu é bom lembrar que podemos facilmente instalar muitas coisas utilizando o utilitário Synaptic acessado do menu principal do Ubuntu: System > Administration > Synaptic Package Manager
Estou precisando rodar outros ambientes virtualizados no windows para poder demonstrar features do weblogic e usar o software de captura de tela que utilizo que é o Jing. As versões do Jing disponíveis atualmente só rodam em windows ou Mac e portanto para demonstrar outros sistemas operacionais decidi utilizar um programa de virtualização.
Já utilizei profissionalmente o VMWare Server que é uma ótima ferramente mas como estou procurando algo gratuito e para uso pessoal optei por baixar e testar o Virtual Box da sun, segue o link: http://www.virtualbox.org/
Vou testá-lo e posteriormente coloco minha impressão sobre este software pois é a primeira vez que irei utilizá-lo. Os sistemas operacionais no meu desktop em casa são o Windows XP 64bits e o Ubuntu linux 10 64 bits. Vou rodar o virtual box no Windows.
A instalação do weblogic server é bem simples, a idéia deste post é fazer um quick start bastante resumido. O link para a documentação oficial de instalação da versão Weblogic 10.3, que é a mais recente e completa, é: http://download.oracle.com/docs/cd/E12840_01/wls/docs103/sitemap.html
Vou demonstrar instalação em um ambiente windows. Vou mostrar o modo de console gráfico para todas as configurações deste tutorial, posteriormente pretendo fazer o mesmo tutorial sem utilizar o modo gráfico no linux.
No windows o processo de instalação é todo gráfico com wizards o que torna tudo bem intuitivo para o usuário. O windows que estou utilizando para estas demonstrações é Windows XP.
Para ver o vídeo da primeira parte deste tutorial que mostra a instalação do Oracle Weblogic Server 10.3 acesse o link abaixo(O instalador já deve ter sido baixado!):
Esta semana precisei fazer uma customização no padrão de forms que utilizo. Basicamente o que estava ocorrendo era que eu precisava mudar o padrão de mensagens de erro do struts 2 utilizando o tema xhtml para não aparecer a mensagem de erro no campo diretamente só em uma lista em cima do formulário desejado e com um ícone mostrando o campo no form.
Fiquei mais uma vez muito satisfeito com a solução do struts 2 para definição destes padrões. Basicamente o struts 2 utiliza uma estrutura de templates e temas que nos dá uma enorme flexibilidade na manipulação destes forms. A documentação do struts tem várias informações sobre isso nos links:
Como não conheco linguagens de templates eu levei cerca de 3 horas e 30 minutos entre o início da minha pesquisa para modificar os templates até conseguir o que queria.
Como ainda não tive tempo para colocar uma formatação decente para apresentação de código fonte, principalmente html, deixo aqui o link do fórum do javaranch onde iniciei um tópico de discussão sobre este assunto e postei todo o código e procedimento que adotei até conseguir chegar a uma solução final, tá tudo explicado lá no fórum(em inglês).
Essa é uma dica rapidinha. Estive procurando por alguns dias um software de captura de telas para utilizar na documentação de sistemas e demonstração de bugs de software. Depois de alguma procura encontrei um site com uma enorme lista: http://www.c4lpt.co.uk/Directory/Tools/capture.html
e alguns testes depois cheguei ao Jing que definitivamente me pareceu a melhor opção. Funciona muito bem e é muito intuitivo e fácil de começar a utilizar. Pode ajudar muito na comunicação entre uma equipe, documentação de sistema e demonstração de bugs. A versão gratuita funciona muito bem e já atende a maioria dos projetos. Vale a pena conferir:
Hoje finalmente encontro tempo para começar a fazer a migração da minha aplicação para utilizar a Floggy que é uma API de persistência para Java ME criada por brasileiros, mais detalhes em : http://floggy.sourceforge.net/
A url para o eclipse é: http://floggy.sourceforge.net/eclipse e o plugin foi baixado corretamente e a versão instalada foi a 1.2.0 conforme a imagem abaixo:
Após isso, seguindo as instruções, reiniciei o eclipse. Depois para adicionar as dependências ao meu projeto no eclipse foi só clicar com o botão direito sobre o projeto e selecionar Floggy > Add Floggy nature. Isso adicionou uma nova dependência ao meu projeto apontando para a library da Floggy, conforme imagem abaixo:
Tudo bem tranquilo, sem nenhum problema. Lembro que no meu ambiente de desenvolvimento estou utilizando Eclipse Europa 3.3.2 com plugin do Eclipse ME: http://eclipseme.org/
Agora com o ambiente configurado estou pronto para iniciar o refactoring do código para substituir as chamadas diretas da API RMS pela utilização da API Floggy.
A primeira coisa interessante que notei estudando os guias da API foi que irei retirar uma camada que existe atualmente no meu projeto destinada a persistência. No meu padrão de desenvolvimento JME eu defini uma camada RMS em um pacote conforme a figura abaixo:
Neste pacote eu defini uma classe base para todas as classes responsáveis pela persistência que é a classe AbstractDBME e para user story do meu sistema eu implementava uma respectiva classe DBME conforme a imagem acima. Estas classes são responsáveis pela persistência utilizando RMS onde existe código como:
/**
* método que persiste o registro do login na base de dados local do device.
*
* @param loginME
* inicializado e com parâmetros carregados.
*/
public void adicionaLogin(LoginME loginME) {
log.debug("Entrou LoginDBME.adicionaLogin()");
try {
int idLoginME = baseDados.getNextRecordID();
loginME.setId(idLoginME);
byte[] b = loginME.toByteArray();
baseDados.addRecord(b, 0, b.length);
}
catch (Exception ioe) {
ioe.printStackTrace();
}
log.debug("Executou LoginDBME.adicionaLogin()");
}
/**
* atualiza status do usuário ativo na base de dados. Somente um usuário
* ativo deve existir por vez em um device.
*
* @param idLogin
* o id
*/
public void setAtivo(int idLogin) {
log.debug("Entrou LoginDBME.setAtivo() setar para ativo o login " + idLogin);
ObjectSet logins = recuperaRegistros();
try {
for (int i = 0; i < logins.size(); i++) {
LoginME loginME = (LoginME) logins.get(i);
// garante que somente o id passado estará como true.
if (loginME.getIdUsuario() == idLogin) {
log.debug("Setando para ativo o login ==>> " + loginME.getLogin() + " idUsuario: " + loginME.getIdUsuario());
loginME.setAtivo(true);
baseDados.save(loginME);
} else{
log.debug("Setando para inativo o login ==>> " + loginME.getLogin() + "idUsuario: " + loginME.getIdUsuario());
loginME.setAtivo(false);
baseDados.save(loginME);
}
}
} catch (Exception e)
{
log.error(e.getMessage());
e.printStackTrace();
}
log.debug("Executou LoginDBME.setAtivo()");
}
No código original existem estes além de muitos outros métodos similares e no meu ponto de vista, mais complexos do que deveriam, o que dificulta muito a evolução e manutenção do meu sistema.
A minha grande expectativa é que utilizando Floggy todo este pacote deixe de existir no meu projeto eliminando esta complexidade desnecessária.
Pelo que percebi a Floggy trabalha com um modelo de persistência muito parecido com o do hibernate e portanto o primeiro passo foi definir as classes do meu modelo que encontram-se no pacote br.com.maweb.controlepeso.jme.model e que são pojos simples com a única diferença que, para atender a uma demanda do RMS, eu havia implementado um padrão onde cada classe do meu modelo tinha a responsabilidade de serializar e recuperar as informações através de métodos fromByteArray e toByteArray.
Exemplo da implementação nos pojos:
public void fromByteArray(byte[] dados) throws IOException {
log.debug("Entrou LoginME.fromByteArray");
ByteArrayInputStream bin = new ByteArrayInputStream(dados);
DataInputStream din = new DataInputStream( bin );
this.id = din.readInt();
this.idUsuario = din.readInt();
this.login = din.readUTF();
this.password = din.readUTF();
this.ativo = din.readBoolean();
log.debug("ControlePesoME.fromByteArray()" + this.toString());
din.close();
log.debug("Executou LoginME.fromByteArray");
}
public byte[] toByteArray() throws IOException {
log.debug("Entrou LoginME.toByteArray");
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream( bout );
dout.writeInt(getId());
dout.writeInt(getIdUsuario());
dout.writeUTF(getLogin() );
dout.writeUTF(getPassword());
dout.writeBoolean(isAtivo());
dout.close();
log.debug("Dados retornados em array de bytes ==>> Id: " + getId() + ", ativo: " + isAtivo());
log.debug("Executou LoginME.toByteArray");
return bout.toByteArray();
}
Essa implementação também deixou de ser necessária após a completa implementação da API Floggy, simplificando bastante o meu código.
Continuando com a implementação a primeira coisa que fiz foi retirar a referência para a interface de marcação que eu utilizava nos meu POJOs do device para garantir a implementação dos métodos toByteArray e fromByteArray que eu utilizava para persistência direta com RMS,retirada a interface e os métodos fromByteArray e toByteArray minha classe ficou então definida somente com os atributos e respectivos getters e setters para as propriedades.
Esta alteração causou problemas na classe de persistência que utilizava o método para fazer a persistência do objeto com RMS em rotinas como:
byte[] b = loginME.toByteArray();
baseDados.addRecord(b, 0, b.length);
Este problema deverá ser resolvido substituindo as rotinas de persistência por chamadas de persistência da API Floggy.
Como mostra o fragmento de código acima eu tinha na minha classe LoginDBME uma referência RecordStore denominada baseDados o que fiz foi mudar esta referência para utilizar o PersistableManager da Floggy.
Também retirei as chamadas a métodos como conectaBase e fechaConexao o que deixou o código bem mais limpo.
Durante o procedimento tive que corrigir vários erros de compilação que apareceram e adaptar vários métodos que utilizavam API RMS.
Um dos pontos a destacar foi a alteração do método que recupera os registros que retornava um RecordEnumeration com todos os registros e agora retorna um ObjectSet com objetos do tipo desejado, isso possibilitou também que eu removesse outros métodos.
No final o que posso dizer é que o processo de implementação no meu caso de uso não foi complexo, levou cerca de 2 horas de trabalho para acertar todas as arestas e o resultado final me agradou MUITO pois simplificou muito a manutenção e evolução do sistema além de ter diminuído considerávelmente a quantidade de código demandada para persistência e esse tempo de implementação com certeza será recuperado pela simplificação da manipulação da camada de persistência.
Pelo pouco que pude ver e fazer com a API recomendo a utilização da API Floggy, sem sombra de dúvidas. Vale a pena!
Agora é implementar nos outros módulos do meu sistema.
[]s
P.S - O único problem que tive foi que a configuração da Floggy "desmarcou" no java build path do meu projeto eclipse a API MicroLog que também utilizo no projeto. Isso fez com que eu ao tentar testar tomasse erro de ClassNofFound apesar da API Microlog estar add no java build path. O que tive que fazer foi selecionar a aba Order and Export e selecionar novamente a API micrologger para ser incluída no meu pacote e tudo voltou a funcionar normalmente.
