Desabafo binário

Inserir tag no cabeçalho html do Portal Gatein

Rodrigo Ramalho da Silva — Tue, 17 Jan 2012 19:45:25 +0000

Esses dias precisei inserir uma tag no cabeçalho de todas as páginas que estivessem no portal gatein.

Existem duas maneiras de fazer isso:

1. Criando um portlet que insere essa tag no da página, carregando pelo método doHeader.

o código do portlet deverá ser semelhante a esse:

public class HeaderExtension extends GenericPortlet {

@Override
protected void doHeaders(RenderRequest request, RenderResponse response) {
Element meta = response.createElement("meta");
meta.setAttribute("http-equiv", "X-UA-Compatible");
meta.setAttribute("content", "IE=edge");
response.addProperty(MimeResponse.MARKUP_HEAD_ELEMENT, meta);
}

@Override
public void doView(RenderRequest request, RenderResponse response) {
PortletRequestDispatcher prd = getPortletContext().getRequestDispatcher("/jsp/index.jsp");
try {
prd.include(request, response);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Com isso basta colocar este portlet no layout do site e ele irá colocar toda vez essa tag no cabeçalho da página. Pode ser usado também pra carregar css, javascript, etc.. (Veja mais)
Porém com essa abordagem tudo que for inserido aparece no final da tag head, ou seja, próximo ao /head. As vezes é necessário que a tag esteja no começo do head, como no caso da tag:

Que é utilizada para compatibilidade com o Internet Explorer.
Com este cenário temos que alterar o fonte do template groovy que o portal utiliza. O arquivo pode ser encontrado em:

$JBOSS_EPP_HOME/server/$SERVER_NAME/deploy/gatein-wcm-extension-2.1.5-CP02.ear/ecm-wcm-extension.war/groovy/portal/webui/workspace/UIPortalApplication.gtmpl

Ps: É necessário explodir o arquivo gatein-wcm-extension-2.1.5-CP02.ear e o ecm-wcm-extension.war

Feita a alteração neste template groovy basta reiniciar o portal.

Autenticação pelo Google utilizando OpenID

Rodrigo Ramalho da Silva — Thu, 12 Jan 2012 04:00:36 +0000

“A API de login federado do Google, com base no protocolo OpenID 2.0, permite que os usuários façam login no seu site ou aplicativo da web com suas Contas do Google. Quando o Google autentica uma conta de usuário, ele retorna um ID de usuário para o seu aplicativo, o que permite que você colete e armazene informações do usuário. O Login federado também permite que você obtenha acesso a determinadas informações sobre a conta do usuário, com a aprovação dele.” http://code.google.com/intl/pt-BR/apis/accounts/

Então… Hands ON! Cabe lembrar que da mesma maneira que faremos para o google podemos fazer para qualquer site que seja um provedor OpenID, como Yahoo, Flickr dentre outros.

Segue uma imagem que tenta representar como ficará o fluxo dessa autenticação.

O usuário entra na tela de login, seleciona o botão para fazer autenticação pelo google.
É feito um direcionamento para autenticação pela página do google.
Ao efetuar a autenticação ocorre o redirecionamento de volta para a página da aplicação.

1. SETUP

Baixe a biblioteca openid4java.

No eclipse crie um projeto Dynamic Web Project.

Fiz comentários quase que linha a linha em todo o código para facilitar o entendimento.

2. ResultType.java

Criei um Enum pra indicar se a autenticação teve sucesso, não sucesso ou se foi redirecionada.


package org.rodrigoramalho.openid.autenticacao;

public enum ResultType {

AUTH_SUCCESS, AUTH_FAILURE, REDIRECT_TO_OPENID_PROVIDER_FAILURE

}

2. Consumer.java

Éssa classe que será responsável pela autenticação utilizando o openid.

O método a seguir authRequest é o método responsável pela ação de quando o usuário clicar no botão de autenticação com o google, fazer o request OpenID e direcionar para a página de autenticação do google.


public ResultType authRequest(HttpServletRequest request, HttpServletResponse response, ServletContext servletContext) throws IOException{

try{

// realm é a url da aplicação + porta ex: http://localhost:8080

String realm = getRealm(request);

// Definimos a url a qual o google deverá retornar após autenticar o usuário

String returnToUrl = new StringBuffer(realm).append(request.getContextPath()) + "/Auth";

// "descobre" o OpenID do fornecedor

List discoveries = manager.discover("https://www.google.com/accounts/o8/id");
// Tentativa de se conectar com o provedor OpenID

// e acessar um endpoint service pra se autenticar

DiscoveryInformation discovered = manager.associate(discoveries);

// Obtém a requisição de autorização que será mandada para o provedor OpenID

AuthRequest authReq = manager.authenticate(discovered, returnToUrl);

// Informa quais atributos deverão ser 'requeridos'

FetchRequest fetch = FetchRequest.createFetchRequest();

fetch.addAttribute("email", "http://axschema.org/contact/email", true);

fetch.addAttribute("firstName", "http://axschema.org/namePerson/first", true);

fetch.addAttribute("lastName", "http://axschema.org/namePerson/last", true);

authReq.addExtension(fetch);

authReq.setRealm(realm);

// coloca o objeto discovered na sessão do usuário

request.getSession().setAttribute("discovered", discovered);

request.getSession().setAttribute("checkResponse", true);

// Encaminha para a página de autenticação do google

response.sendRedirect(authReq.getDestinationUrl(true));

}

catch (OpenIDException e){

e.printStackTrace();

}

return ResultType.REDIRECT_TO_OPENID_PROVIDER_FAILURE;

}

Após fazer a autenticação pelo google, deve-se verificar se essa autenticação foi válida, para isso deve-se chamar o método verifyResponse


public ResultType verifyResponse(HttpServletRequest httpReq){

try{

// extrai os parametros que vem do HTTP request do OpenID provider.

ParameterList response = new ParameterList(httpReq.getParameterMap());

// Lembra que a gente colocou esse objeto na sessão?

DiscoveryInformation discovered = (DiscoveryInformation) httpReq.getSession().getAttribute("discovered");

// Extrai os parametros da url

StringBuffer receivingURL = httpReq.getRequestURL();

String queryString = httpReq.getQueryString();

if (queryString != null && queryString.length() > 0){

receivingURL.append("?").append(httpReq.getQueryString());

}

// Valida o response, verificar se o ConsumerManager é o mesmo que efetuou o request

VerificationResult verification = manager.verify(receivingURL.toString(), response, discovered);

// Analisa o resultado da verificação e extrai o identificador de verificação

Identifier verified = verification.getVerifiedId();

if (verified != null){

AuthSuccess authSuccess = (AuthSuccess) verification.getAuthResponse();

if (authSuccess.hasExtension(AxMessage.OPENID_NS_AX)){

// Extrai os atributos que fizemos a requisição (no fetchRequest)

FetchResponse fetchResp = (FetchResponse) authSuccess.getExtension(AxMessage.OPENID_NS_AX);

Map userAttributes = fetchResp.getAttributes();

User user = new User();

user.setEmail(userAttributes.get("email").toString());

String nome = userAttributes.get("firstName") + " "+ userAttributes.get("lastName");

user.setName(removeBrackets(nome));

// Coloca o usuário na sessão

httpReq.getSession().setAttribute("user", user);

}

return ResultType.AUTH_SUCCESS;  // success

}

}catch (OpenIDException e){

e.printStackTrace();

}

httpReq.getSession().removeAttribute("checkResponse");

return ResultType.AUTH_FAILURE;

}

3. AuthServlet.java


protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

try {

if (request.getParameter("logout") != null) {

logoutUser(request, response);

}else{

Consumer consumer = new Consumer();

HttpSession session = request.getSession();

boolean checkResponse = session.getAttribute("checkResponse") != null ? true : false;

if (!checkResponse){

consumer.authRequest(request, response, getServletContext());

}else{

consumer.verifyResponse(request);

RequestDispatcher dispatcher = request.getRequestDispatcher("login.jsp");

dispatcher.forward(request, response);

}

}

} catch (ConsumerException e) {

e.printStackTrace();

}

}

4. login.jsp




<%@page import="org.rodrigoramalho.openid.beans.User"%>

<% User user = (User) request.getSession().getAttribute("user"); %>

<% if ( user == null){ %>

Sign in













<% } else {%>

 Bem vindo <%= user.getName() %>

Logout

<%} %>

O código fonte do projeto.

Bash Script find and replace

Rodrigo Ramalho da Silva — Tue, 03 Jan 2012 14:35:38 +0000

Faz substituição no texto de arquivos.

A linha de comando abaixo faz uma procura e substitui todas as ocorrências em arquivos textos da palavra “procure_por_isso” nos diretórios abaixo de “/home/meu_diretorio” e substitui por ”substitua_por_isso”.

find "/home/meu_diretorio" -type f -exec sed -i "" -e s/procure_por_isso/"substitua_por_isso"/g {} \;
.

Faz substituição no nome de arquivos e diretórios

O script abaixo renomeia todos os arquivos e diretórios com o nome de “procure_por_isso” e substitui por “substitua_por_isso” a partir do diretório “/home/procure_por_aqui”

  FILES=$(find /home/procure_por_aqui -name "procure_por_isso")

  for FILE in $FILES; do

    NAME="$FILE"

    NAME_REPLACED=$(echo $FILE | sed -e s/"procure_por_isso"/"substitua_por_isso"/g)

    mv $NAME $NAME_REPLACED

  done

Cabe lembrar que caso queira pesquisar pela parte do nome, no parametro -name pode-se utilizar o: *

por exemplo:

FILES=$(find /home/procure_por_aqui -name *procure_por_isso*)

Vai procurar por qualquer ocorrência de “procure_por_isso”. Segue um exemplo de alguns resultados possíveis:

abc_procure_por_isso

procure_por_isso_abc

procure_por_isso

Introdução a Cluster

Rodrigo Ramalho da Silva — Tue, 11 Oct 2011 17:04:08 +0000

Cluster ?

Cluster é o ato de de rodar a mesma aplicação em vários servidores de aplicação simultaneamente com cada aplicação estando ciente das outras que estão no cluster. Um servidor de aplicação em um cluster é chamado de nó.

Pra quê ?

Creio que a melhor forma de entender o por que? é com um exemplo, então:

O servidor em que minha aplicação está rodando suporta 1000 usuários simultâneos, porém hoje 2000 usuários simultâneos acessaram minha aplicação e o servidor caiu.
E agora José ? Temos 2 opções, ou adquiro recursos para o servidor que já está rodando ou adiciono outras máquinas para responderem esses requests, desafogando a primeiro servidor.

Cluster: Vertical x Horizontal

Clusters podem ser formados com nós rodando em uma máquina ou em várias máquinas. Essa formação do cluster é comumente se referida como topologia.

Horizontal: Quando os nós do cluster estão em diferentes máquinas.
Vertical: Quando os nós do clusters estão na mesma máquina

No cluster horizontal se acontece alguma falha com a máquina (ex: queda de energia, queimar algum periférico, etc) a outra máquina assume o cluster sem problemas. Se a máquina do cluster vertical ocorrer algum problema todos os servidores que estavam rodando nela, serão comprometidos. Em outras palavras um cluster horizontal é uma melhor opção para alta disponibilidade.

Balanceamento de Carga

Balanceamento de carga é a maneira de distribuir a carga de entrada entre os diferentes servidores de aplicação, fazendo com que sua aplicação seja escalável e tenha alta disponibilidade. Escalabilidade é o termo usado para descrever a habilidade de fazer com que sua aplicação manipule mais carga adicionando hardware e/ou criando instâncias redundantes sem alterar o código. Então um cluster sem balanceamento de carga faz pouco ou nenhum sentido.

Alta disponibilidade

Caso se tenha uma aplicação que seja toda stateless, pode-se garantir alta disponibilidade apenas colocando um balanceador de carga na frente de vários servidores com a mesma aplicação deployada (note, sem cluster). Esse mecanismo é conhecido como Failover. Cabe a ressalva que no failover nenhum tipo de estado da aplicação é replicado.

Porém se a aplicação for stateful o problema é mais em baixo, imagine que você esteja em um site de compras o seu carrinho já possui 10 itens derrepente o servidor cai, você não vai gostar nada de quando clicar no próximo botão cair em um tela de login e o seu carrinho aparecer zerado. O failover não replica estado então não seria adequado para esse tipo de situação para isso temos o mecanismo a seguir:

Replicação e Tolerância a falhas (Replication e Fault Tolerance)

Um servidor com tolerância a falhas promove alta disponibilidade e continua se comunicando com o cliente mesmo que o servidor caia, ou seja o estado do cliente é mantido. Então no exemplo anterior se o cluster tiver tolerância a falhas então o servidor cairá o cliente será balanceado para outro nó e continuará logado na aplicação com seu carrinho de compras com todos os itens como se nada tivesse acontecido.
Mas o que contém nesse estado do cliente?
Basicamente duas coisas: Dados de sessão e de entidades.

Dados de sessão (Session data) são mantidos em memória pela aplicação ou por mecanismos de cache habilitados pelo servidor de aplicação.
Dados de entidade (Entity data) são mantidos em banco de dados.

Para ser tolerante a falhas o estado associado a uma aplicação deve redundantemente disponível, ou seja, os nós devem replicar o estado entre cada nó do cluster

Fault tolerance = fail over + state replication

É muito comum escutarmos conversas de pessoas pensando em cluster como uma forma de melhorar performance, e como podemos ver cluster é sinônimo de disponibilidade e dependendo do cluster pode é trazer défict de performance devido o fato do servidor de aplicação ter que ficar replicando estado, sincronizando cache, etc.

Existem diferentes formas dessa replicação de estado acontecer em um cluster, mas para não deixar o post muito longo vou encerrando por aqui.

Fonte:
JBoss in Action – Chapter 12 – Understanding Cluster.

jQuery placeholder plugin (Twitter Like)

Rodrigo Ramalho da Silva — Wed, 28 Sep 2011 06:32:34 +0000

Recentemente programando com minha amiga Carolina Mascarenhas ela fez um placeholder bem parecido com o do twitter, apenas dei uma acabada no código e coloquei no formato de plugin.

Placeholder é quando o label de um campo input está localizado dentro do pŕoprio input. Como podemos ver na imagem abaixo:

Segue a página contendo o exemplo: http://jspace.com.br/jquery-placeholder-plugin/

Como utilizar:

Adicionar os arquivos jquery.js, jquery.placeholder.js e o placeholder.css a página.

O html deve respeitar a seguinte estrutura:

Email

Onde o conteúdo que estiver dentro da tag será o que aparecerá dentro do input.

Tendo isso como premissa, o código para adicionar o placeholder deverá ser o seguinte:

 jQuery(".username").placeholder();

Onde “.username” é a classe da div. Também pode ser utilizado o id.

Algumas opções podem ser especificadas:

jQuery(".username").placeholder({

color_onfocus: "b9b9b9",

color_background_onfocus: "white"
});

Cabe lembrar que o HTML5 tem suporte nativo ao placeholder bastando apenas colocar a propriedade placeholder=”Rodrigo Ramalho” dentro do input.

exemplo:

Simples assim. Porém nem todos os browsers suportam HTML5 ainda.

Pra quem quiser contribuir e/ou entender melhor o projeto, o source está no meu github:

https://github.com/hodrigohamalho/jquery-placeholder-plugin

Cheat Sheets

Rodrigo Ramalho da Silva — Fri, 08 Jul 2011 04:32:53 +0000

Para evitar o problema de ter que ficar dando uma googlada pra lembrar 'aquele' comando
que está lhe falhando a memória,  basta aprender a explorar os "cheat sheets". Cheat sheet 
é um resumo dos principais comandos de uma determinada API. Hoje precisei lembrar alguns
comandos do heroku e achei esse cheat sheet no qual acrescentei algumas linhas.

Heroku Cheat Sheet 
=== General Commands
 help                         # show this usage
 version                      # show the gem version

 list                         # list your apps
 create []              # create a new app

 keys                         # show your user's public keys
 keys:add [] # add a public key
 keys:remove         # remove a key by name (user@host)
 keys:clear                   # remove all keys
 ps                           # display process

=== App Commands (execute inside a checkout directory, or use --app )

 info                         # show app info, like web url and git repo
 open                         # open the app in a web browser
 rename              # rename the app
 dynos                   # set the app to use the specified qty of dynos

 sharing:add           # add a collaborator
 sharing:remove        # remove a collaborator
 sharing:transfer      # transfers the app ownership

 domains:add          # add a custom domain name
 domains:remove       # remove a custom domain name
 domains:clear                # remove all custom domains

 ssl:add            # add SSL cert to the app
 ssl:remove           # removes SSL cert from the app domain

 rake                # remotely execute a rake command
 console             # remotely execute a single console command
 console                      # start an interactive console to the remote app

 restart                      # restart app servers
 logs                         # fetch recent log output for debugging
 logs:cron                    # fetch cron log output

 maintenance:on               # put the app into maintenance mode
 maintenance:off              # take the app out of maintenance mode

 config                       # display the app's config vars (environment)
 config:add key=val [...]     # add one or more config vars
 config:remove key [...]      # remove one or more config vars
 config:clear                 # clear user-set vars and reset to default

 db:pull []     # pull the app's database into a local database
 db:push []     # push a local database into the app's remote
 database
 db:reset                     # reset the database for the app
-- Postgres databases ---
 pg:info                      # show db info
 pgbackups                    # list postgres backups
 pgbackups:url id             # get url to download backup
 pgbackups:capture            # capture a new backup
 pgbackups:destroy id         # destroy bakup

 bundles                      # list bundles for the app
 bundles:capture []   # capture a bundle of the app's code and data
 bundles:download             # download most recent app bundle as a tarball
 bundles:download     # download the named bundle
 bundles:animate      # animate a bundle into a new app
 bundles:destroy      # destroy the named bundle

 addons                       # list addons
 addons:add name [key=value]  # install addon (with zero or more config vars)
 addons:remove name           # uninstall an addons
 addons:clear                 # uninstall all addons

 destroy                      # destroy the app permanently

=== Example:

 rails myapp
 cd myapp
 git init
 git add .
 git commit -m "my new app"
 heroku create
 git push heroku master

Introdução

Rodrigo Ramalho da Silva — Thu, 21 Apr 2011 17:57:32 +0000

Já faz um bom tempo que queria fazer um blog, mas sempre acabava adiando. Enquanto isso muitos posts preciosos foram perdidos.

Importante é que enfim criei um aqui no wordpress e apontei pro DNS (rodrigoramalho.org) que tinha registrado há muito tempo e nem sabia mais da existência.

Creio que não preciso me apresentar porque tem uma aba constante aqui no blog só falando de mim.

Espero que me conheçam um pouco mais a cada post e que gostem do que será apresentado.

Abraço.