GuinuX Solutions e Nets Telemática Blog

Fala Galera, daqui a poucos dias nosso querido Ubuntu estará saindo do forno.

Acompanhe todos os momentos do FISL 9 em Porto Alegre, as paletras, palestrantes, estaremos publicando tudo que estará acontecendo num dos maiores eventos de software livre. Dias 17/04 a 19/04.

Presença Garantida.

FISL sem foto com Maddog sem chances…..

Guilherme e a lenda viva do Linux quem não conhece?

<< Parte 1 clique aqui
Ok, agora que conhecemos a perspectiva de desenvolvimento de plug-in vamos criar o nosso projeto RCP.

Criando o Projeto
Com e perspectiva de plug-in aberta siga os passos para criar um novo projeto:
1. Vá em Arquivo > Novo > Projeto no menu principal que terá como resultado a tela a seguir:

2. Escreva primeirospassos no nome do projeto e clique em Avançar.

3. Mantenha todos os valores dos campos de texto como estão e selecione Sim, como na foto abaixo, então clique em Avançar

4. Marque a opção e selecione como na imagem abaixo e clique em Concluir.

Entendendo o plug-in manifest
Após finalizar as etapas de novo projeto, na visualização “Explorador de pacotes” será exibido o projeto primeirospassos e na tela principal será exibida a Visão geral do projeto como ilustra a imagem a seguir:

Esta visualização é uma poderosa ferramenta de edição do plug-in manifest gerado. O plug-in manifest é responsável pela definição de recursos, dependências e extensões que será utilizado pelo Eclipse para o seu gerenciamento da aplicação. O arquivo plugin.xml está localizado na raiz do projeto e através da aba plug-in podemos modificá-lo para atender as nossas necessidades.

Utilizando a aba plug-in.xml o código a ser exibido será este:

A Linha 5 até 13 define o primeiro ponto de extensão que aponta para org.eclipse.core.runtime.applications. Essa extensão declara o ponto de entrada para a aplicação RCP. Ao definir o elemento o elemento deve ser definido com o nome da classe que será executada quando a aplicação RCP for iniciada. A segunda extensão que corresponde às linhas 14 até 21 está definida para org.eclipse.ui.perspectives e adiciona a perspectiva na aplicação.

Entendendo a classe de Perspectiva

Na classe primeirospassos.Perspective teremos o código a seguir:

package primeirospassos;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

public class Perspective implements IPerspectiveFactory
{
   public void createInitialLayout(IPageLayout layout)
   {
   }
}

O método createInitialLayout define o layout inicial de todas as views, para esse exemplo não há necessidade de modificação desse método.

Entendendo o a classe ApplicationWorkBenchAdvisor

Na classe primeirospassos.ApplicationWorkbenchAdvisor teremos o código a seguir:

package primeirospassos;

import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;

public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor
{
   private static final String PERSPECTIVE_ID = “primeirospassos.perspective”;

   public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer)
   {
      return new ApplicationWorkbenchWindowAdvisor(configurer);
   }

   public String getInitialWindowPerspectiveId()
   {
      return PERSPECTIVE_ID;
   }
}

Em breve parte 3.

Marlus Cadanus
marlus@guinux.com.br

Todo mundo já deve ter ouvido falar de Ruby on Rails sobre suas facilidades e potencialidades aliadas a uma ótima linguagem integrada com um ótimo framework que esta deixando muito programador JAVA de cabelo em pé. Pois bem não cabe desse artigo discutirmos as maravilhas de RoR para os mais interessados nesse link encontra-se um arquivo que contém um livro completo de Ruby On Rails em Inglês, capitulo de demonstração do ótimo livro do Fábio Akita e uma apresentação criado por ele. O Goldberg é um generator de Rails que permite que você crie uma estrutura para seu projeto, ele tem autenticação de usuários, navegação do sistema de menu completamente gerenciável, segurança e todo menu é integrado possibilitando apena linkarmos as ações dos controllers ou content view. Um sistema de CMS está integrado dentro dele, sua implementação é extremamente trivial.

Bom chega de história e vamos por a mão na massa:

Primeiramente no seu sistema deve ter instalado o suporte a Ruby on Rails, em distribuições Linux atuais sua instalação é muito simples devido a facilidade dos gerenciadores de pacotes, você precisa necessariamente de três pacotes - Ruby1.8.5 ou maior, Rubygems, e o próprio Rails que pode ser instalado através do gem e lógicamente do bom e funcional Mysql. Por exemplo:
No Ubuntu seria assim:
$ sudo apt-get install ruby irb1.8 ri1.8 rdoc1.8 ruby1.8-dev build-essential
$ wget http://rubyforge.rubyuser.de/rubygems/rubygems-0.9.2.tgz
$ tar xzvf rubygems-0.9.2.tgz
$ cd rubygems-0.9.2
$ sudo ruby setup.rb
$ sudo gem install rails –include-dependencies
$ sudo gem install mysql
Clique aqui para para maiores detalhes.
No Fedora Core 6 você poderá utilizar o yum ou o gerenciador de pacotes gráfico.
No Mandriva utilize o urpmi ou o gerenciador de pacotes gráfico.

MacosX oferece um ótimo ambiente para se trabalhar com Rails, para usuários de sistemas Windows RoR também dá suporte, veja com mais detalhes nesse link.

1- Criando seu projeto
$ rails meusite — veja a imagem

Veja que toda a estrutura MVC de seu projeto foi criada automaticamente.(Para projetos em andamento é possível instalar o Goldberg sem problemas).

2- Instalando o generator Goldberg
$ sudo gem install RedCloth
$ sudo gem install plugin_migrations
Crie no seu home diretório que ficará os generators adicionais.
$ mkdir ~/.rails
$ mkdir ~/.rails/generators
$ cd ~/.rails/generators
Baixe o Golddberg através do site e descompacte dentro desse diretório ou baixe através do svn como abaixo:
$ svn export svn://rubyforge.org/var/svn/goldberg/trunk/goldberg — veja imagem

Pronto agora vamos aplicar o Goldberg em nosso projeto.
2- Configure sua conexão do banco de dados no arquivo de configuração.(Lógico tenha sua base já criada no mysql)
$ vim config/database.yml — veja imagem

3- Escolha qual template você irá utilizar são eles:
* default: layout padrão em azul, menu no topo.

* ewnf: “Earth Wind and Fire”

* snooker: “Snooker”

* spoiled_brat: “Spoiled Brat”

4- Aplique o goldberg em seu projeto
$ ./script/generate goldberg template
Note que sem especificar o template ele utilizará o default, caso você queira utilizar outro template seria assim:
$ ./script/generate goldberg snooker
Rode o Migrations:
$ rake goldberg:install

Pronto o Goldberg já foi instalado no seu projeto.
Veja como ficou:
$ ./script/server
Abra seu browser:
http://localhost:3000 — veja a imagem


Log como admin/admin.

Personalizando o template escolhido:
Como Rails tem incorporado o MVC o goldberg se instala seguindo essa estrutura por exemplo:
1- Para alterar o css do seu projeto, cores, links, disposições, tamanhos, etc…
$ vim public/goldberg/stylesheets/layout.css

2- Para alterar facilmente o layout da pagina inicial utilize sua ferramenta html preferida e edite o seguinte arquivo:
$ vim app/views/layouts/application.rhtml

O restante fica por sua conta.

Guilherme Straioto
guilherme@guinux.com.br
41 3941 4567

O que é RCP?
O RCP (Rich Client Plataform) é um conceito de aplicação visualmente rica independente de plataforma.

Primeiramente o RCP fornece o Eclipse como base de desenvolvimento na qual os desenvolvedores o utilizarão para criar as suas aplicações. Uma aplicação é basicamente um plug-in customizado para atender as necessidades requisitadas, utilizando os componentes gráficos existentes no Eclipse.

SWT e JFace
Ao examinar o Eclipse, podemos perceber que ele não foi desenvolvido com a API padrão do Java para construção de Interfaces Gráficas (AWT/Swing). Ao criarem o projeto Eclipse, foram desenvolvidas duas API´s gráficas, que podem ser utilizadas fora do Eclipse, que são:

• Standard Widget Toolkit (SWT): SWT é uma API que cria componentes gráficos baseados ao sistema operacional. Dessa maneira as aplicações tem uma aparência nativa onde for que estejam sendo utilizadas.
• JFace: O JFace é também uma API, que é utilizado para complementar o SWT, fornecendo componentes visuais e utilidades práticas para facilitar o desenvolvimento das interfaces gráficas.

Arquitetura dos plug-ins do Eclipse
Uma aplicação baseada no Eclipse RCP mantém as carecterísticas do Eclipse, sendo que as funcionalidades relacionadas a editores, views, perspectivas podem ser facilmente utilizadas na nova aplicação. O novo produto exportado não deixa de ser um plug-in do Eclipse que é utilizado para adicionar novas funcionalidades e capacidades para o ambiente fora do Eclipse.

Para um plug-in ser utilizado no fora do Eclipse (ser uma aplicação), ele precisa definir diversas extensões. Uma extensão pode adicionar funcionalidades diretamente para o ambiente, ou estender uma outra extensão existente.
O arquivo plugin.xml descreve como todas as extensões irão interagir com a plataforma de execução do Eclipse e define as dependências necessárias.

Primeira aplicação com RCP
Para iniciar a criação da primeira aplicação RCP serão necessário 6 passos até a execução do aplicativo. São eles:

• Identificar os pontos de extensão.
• Definir o plug-in manifest
• Implementar as extenções
• Definir as classes de Workbench
• Definir a classe Application
• Exportar a aplicação

Usando a perspectiva de desenvolvimento de plug-in:
No eclipse existe uma perspectiva chamada “Desenvolvimento de plug-in” (Plug-in Development Enviroment - PDE), nessa perspectiva contém tudo que é necessário para desenvolver um plug-in para o eclipse ou uma aplicação RCP. Acesse essa perspectiva através dos seguintes passos:

1. Inicie o Eclipse.
2. Selecione Window > Open Perspective > Other. O resultado será a exibição da janela a seguir:

3. Escolha “Plug-in Development” na lista de perspectivas e então clique em OK. O resultado será a tela a seguir:

Próxima Parte (2/3): Criando o projeto e definindo as classes Application e Workbench.

Murilo Cadanus
murilo@guinux.com.br

Em toda a internet existe uma imensa variedade de configurações de Firewalls em Linux, o objetivo desse artigo é prover uma outra opção a comunidade. Hoje precisamos controlar toda entrada e saída da nossa rede DMZ e LAN de acessos indevidos. Primeiramente instale uma distribuição de Linux atual com o Kernel 2.6 em diante, eu indico o Ubuntu Server 6.10, dia 13 de abril será lançado a nova versão do Ubuntu. Esse artigo é dividido em duas situações, a primeira seria controlar todas as saídas para Internet da nossa rede local, tratando as portas seletivamente, através de NAT POSTROUTING e a segunda controlando os acessos de entrada. Vamos seguir abaixo o que deverá ser feito:

Crie um script para tratar com maior facilidade abertura de portas com destino POSTROUTING - Saída
Exemplo abaixo:

portas_saida.sh
_________________________________________________________________________________________

#!/bin/sh
# ips permitidos
IPS=”10.0.0.0/24 10.10.1.0/24 10.10.2.0/24 10.10.3.0/24″
# portas permitidas
PORTAS=”110 25 3456 109 3007 4449 11001 10110 2012 2631 7700 50000 3001″
for porta in $PORTAS
do
for ip in $IPS
do
/sbin/iptables -t nat -A POSTROUTING -p tcp -s $ip –dport $porta -j MASQUERADE
/sbin/iptables -t nat -A POSTROUTING -p udp -s $ip –dport $porta -j MASQUERADE
done

done

___________________________________________________________________________________________
Persolalize esse script conforme sua necessidade.

No seu arquivo de regras de firewall após a regra de mudança de política adicione uma linha chamando esse arquivo.
Exemplo:

….
….
/sbin/iptables -t nat -P POSTROUTING DROP
sh portas.sh

Assim seu arquivo de Firewall não ficará tão poluído e seu gerenciamento ficará mais organizado.

Para tratar INPUT utilizaremos o mesmo conceito, porém fecharemos todas as portas de outra maneira:

no arquivo de regras de firewall, você deverá chamar o arquivo de liberação de portas antes da regra que fechamento:

ex

….
…
sh portas_saida.sh
/sbin/iptables -A INPUT -p tcp –syn -s 10.0.0.0/255.255.255.0 -j ACCEPT (Abre para a rede local)

/sbin/iptables -A INPUT -p tcp –syn -j DROP (Fecha tudo)

Exemplo do script para tratar entradas

portas_entrada.sh
_________________________________________________________________________________________

#!/bin/sh
# ips permitidos
IPS=”0/0″
# portas permitidas
PORTAS=”110 25 22 8080″
for porta in $PORTAS
do
for ip in $IPS
do
/sbin/iptables -A INPUT -p tcp -s $ip –dport $porta -j ACCEPT
/sbin/iptables -A INPUT -p udp -s $ip –dport $porta -j ACCEPT
done

done

Bom imagino que ajudei alguns adminstradores de rede e segurança. Estou a disposição para dúvidas e críticas.

Guilherme Straioto
guilherme@guinux.com
41 3941 4567