Monday, March 30, 2015

Spark: Java Web com MongoDB a partir do método main

O Spark é um micro-container para aplicações Web em Java. Baseado no Sinatra, um ambiente para execução de aplicações Web em Ruby, trata-se de uma tecnologia leve e compacta. O projeto, até o momento, não é apadrinhado por nenhum player (empresa / fundação). A última versão emprega componentes e usa o modelo de programação do Java 8, tornando o código mais limpo e direto.

Trata-se de uma alternativa bem interessante para executar projetos, sem nenhuma burocracia, com foco apenas no código das funcionalidades. O trecho de código a seguir foi extraído do site do projeto, o tradicional HelloWorld, na versão Spark. Parecido com uma aplicação Java pura, o ponto de entrada é o método main. Nele usamos o método get do Spark para definir o fluxo de processamento para uma determinada URL:
import static spark.Spark.get;

public class HelloWorld {
    
    public static void main(String[] args) {
        get("/", (request, response) -> "Bem-vindo ao Spark!");
    }
    
}

Uma vez que a aplicação é executada e a URL http://localhost:4567/ acionada, o código dentro do método main é processado e o texto Bem-vindo ao Spark! apresentado pelo navegador. O Spark usa a porta 4567 por default.

Além do método get, na classe spark.Spark existem diversos métodos para semantica HTTP, como por exemplo: post, put, delete. A estrutura é bem simples, esses métodos possuem uma versão recebendo os argumentos:
  • String path: indica a URL que quando acionada executa o fluxo de código;
  • Route route: uma SAM (Lambda Java 8) que define o método handle responsável pelo fluxo de execução, com os argumentos request e response, retornando Object
Com o Maven, o setup do Spark é trivial. Basta definir a dependência para o JAR spark-core, de 89Kb.

Tenho usado o Spark a algum tempo, para implementar projetos pontuais. Vou destacar um projeto, baseado nas demonstrações da YaW, aonde demonstro como utilizar o MongoDB em uma aplicação Java Web. O projeto foi compartilhado e está disponível no meu Github. Outro detalhe sobre esse projeto é que o front-end foi desenvolvido com a tecnologia Freemaker, um template engine responsável por gerar HTML a partir de templates.

A seguir o trecho da classe MercadoriaController, responsável por carregar a lista de mercadorias:
    ...
    get("/", (request, response) -> {
        List mercadorias = mercadoriaDao.getAll();
        
        SimpleHash root = new SimpleHash();
        root.put("activeLista", true);
        root.put("mercadorias", mercadorias);
        
        if (request.params(":error") != null) {
            root.put("error", request.params("error"));
        }
            
        return new ModelAndView(root, "lista_template.ftl");
    }, new CustomFreeMarkerEngine());
    ...

Além de usar os componentes de acesso, o método get faz uso de FreeMarkerEngine para carregar o template Freemaker. A informação do template e o bean, com os dados dinâmicos para gerar o HTML são definidos no componente ModelAndView.

Nesse outro trecho da controller, o código que coloca a mercadoria em edição:
    ...
    get("/edit/:id", (request, response) -> {
        String idMercadoria = request.params(":id");
        Mercadoria mercadoria = null;
        
        try {
            mercadoria = mercadoriaDao.findById(new ObjectId(idMercadoria));
        } catch (Exception ex) {
            response.redirect("/?error=Registro não econtrado!");
            return null;
        }
         
        SimpleHash root = new SimpleHash();
        root.put("activeIncluir", true);
        root.put("mercadoria", new MercadoriaConverter().toRequest(mercadoria));
            
        return new ModelAndView(root, "mercadoria_template.ftl");
    }, new CustomFreeMarkerEngine());
    ...

Além do Freemaker, utilizamos nesse projeto o Bootstrap e JQuery.

No site oficial e no Github do Spark são disponibilizados maiores detalhes sobre o projeto.

@edermag

Monday, March 16, 2015

Instalar e configurar vsftpd (ftp) no Ubuntu

O vsftpd é um servidor FTP, free, para Linux que oferece boa performance e segurança, com configuração relativamente simples. Nesse post eu demonstro como instalar e configurar o vsftpd com usuários virtuais. Usuários que acessam o FTP, mas que não possuem acesso ao Linux (server). O Linux utilizado como referência é o Ubuntu Server 14.04. Os usuários virtuais são persistidos no formato db4 (Berkeley DB).

Primeira etapa é instalar o vsftpd e db-utils (se ainda não estiver instalado):
$ sudo apt-get install vsftpd db-utils

Assim que a instalação do vsftpd estiver concluída, faça um backup do arquivo vsftpd.conf (original):
$ sudo cp /etc/vsftpd.conf /etc/vsftpd.conf.back

Modifique o arquivo vsftpd.conf para que contenha apenas o conteúdo:
$ sudo apt-get install vsftpd db-utils

Assim que a instalação do vsftpd estiver concluída, faça um backup do arquivo vsftpd.conf:
$ sudo cp /etc/vsftpd.conf /etc/vsftpd.conf.back

Modifique o conteúdo do arquivo vsftpd.conf para que contenha apenas as linhas:
listen=YES
anonymous_enable=NO
local_enable=YES

# Usuarios virtuais com os mesmos privilegios de usuarios locais
virtual_use_local_privs=YES
write_enable=YES

# Nome do servico PAM (Pluggable Authentication Modules) - em /etc/pam.d/
pam_service_name=vsftpd.virtual

# Ativa usuarios virtuais
guest_enable=YES

# Define o diretorio home para cada usuario virtual, baseado em um template: /home/{virtual}/$USER
user_sub_token=$USER

# usuario local (raiz), acima dos usuarios virtuais: vftpd - /home/vftp
local_root=/home/vftp/$USER

# Restringindo usuarios as suas respectivas pastas (home)
chroot_local_user=YES
allow_writeable_chroot=YES

# Esconde informacoes do dono
hide_ids=YES

# Habilita o log /var/log/vsftpd.log
xferlog_enable=YES


Agora vamos criar o banco de dados dos usuários virtuais do vsftpd. Para simplificar a manipulação vou criar dois usuários: joao e maria. Ambos serão armazenamos, inicialmente, em um arquivo texto e posteriormente convertidos em arquivo db4. O arquivo texto será organizado em linhas, primeiro o username e depois password. Os arquivos são mantidos no diretório /etc/vsftpd (será necessário criar esse diretório):
$ sudo mkdir /etc/vsftpd
$ sudo vi users.txt

Coloque o seguinte conteúdo no arquivo users.txt:
joao
joao123
maria
maria456

Salve o arquivo e execute as instruções para: converter para formato db4; modificar o acesso ao arquivo:
$ db_load -T -t hash -f users.txt vsftpd-virtual-user.db 
$ chmod 600 vsftpd-virtual-user.db

Se for conveniente, remova o arquivo users.txt. Fique atento para a inclusão de novos usuários, caso deseje remover o arquivo texto.

Próxima etapa é criar o arquivo PAM e indicar que o repositório de usuários (db4):
$ sudo vi /etc/pam.d/vsftpd.virtual

Coloque o seguinte conteúdo no arquivo vsftpd.virtual:
auth       required     pam_userdb.so db=/etc/vsftpd/vsftpd-virtual-user
account    required     pam_userdb.so db=/etc/vsftpd/vsftpd-virtual-user
session    required     pam_loginuid.so

Agora é o momento de criar a estrutura de pastas no Linux, aonde os arquivos trafegados via FTP serão mantidos. Cada pasta será devidamente vinculada ao usuário, de acordo com as configurações realizadas previamente no vsftpd:
$ mkdir -p /home/vftp/{joao,maria}

Ajustar o dono e o grupo desses diretórios:
$ chown -R ftp:ftp /home/vftp

Repita os dois últimos comandos para cada novo usuário adicionado ao vsftpd.

Última etapa é reiniciar o serviço vsftpd:
$ service vsftpd restart

O teste pode ser via comando ftp do Linux, ou no Firefox via plugin FireFTP. Indique a url, o login (ex joao) e a senha (ex joao123).

Documentação utilizada como referência:
@edermag