Image Image Image Image Image
Scroll to Top

Topo

xml

05

jan
2012

Sem Comentários

Em Blog
JavaScript
JSON

Por Allison

Introdução: JSON

Em 05, jan 2012 | Sem Comentários | Em Blog, JavaScript, JSON | Por Allison

Afinal, o que é JSON?

JSON é basicamente um formato leve de troca de informações/dados entre sistemas. Mas JSON significa JavaScript Object Notation, ou seja, só posso usar com JavaScript correto? Na verdade não e alguns ainda caem nesta armadilha.

O JSON além de ser um formato leve para troca de dados é também muito simples de ler. Mas quando dizemos que algo é simples, é interessante compará-lo com algo mais complexo para entendermos tal simplicidade não é? Neste caso podemos comparar o JSON com o formato XML.

Vamos visualizar esta diferença?


XML

<?xml version="1.0" encoding="UTF-8"?>
  <id>1</id>
  <nome>Alexandre Gama</nome>
  <endereco>R. Qualquer</endereco>
</xml>

JSON

{"id":1,"nome":"Alexandre Gama", "endereco":"R. Qualquer"}

Bom, é notável a diferença. Visualmente o segundo trecho (em JSON) é mais fácil de ler. Mas só existe essa diferença entre os dois? Na verdade não. Podemos listar algumas outras vantagens:

Vantagens do JSON:

– Leitura mais simples

– Analisador(parsing) mais fácil

– JSON suporta objetos! Sim, ele é tipado!

– Velocidade maior na execução e transporte de dados

– Arquivo com tamanho reduzido

– Quem utiliza? Google, Facebook, Yahoo!, Twitter…

Estas são algumas das vantagens apresentadas pelo JSON. Agora vamos ao que interessa: Código!

Vamos fazer um exemplo extremamente simples nesta primeira parte e avançaremos no próximo artigo, inclusive falando sobre JSON em páginas Web.

Qual biblioteca usar?

Existem diversas bibliotecas para trabalharmos com JSON e Java. Usaremos no nosso estudo o json.jar que você pode baixar tranquilamente neste link

O nosso caso de estudo será simples: Teremos uma classe Carro que será a nossa classe POJO e a classe EstudoJSON que terá o nosso famoso método main.

Classe Carro

package br.com.json;

public class Carro {
    private Long id;
    private String modelo;
    private String placa;

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getModelo() {
        return modelo;
    }
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
    public String getPlaca() {
        return placa;
    }
    public void setPlaca(String placa) {
        this.placa = placa;
    }

        //Aqui fizemos o Override do método toString() para visualizar a impressão com o System.out.println()
    @Override
    public String toString() {
        return "[id=" + id + ", modelo=" + modelo + ", placa=" + placa
                + "]";
    }

}

Esta é uma classe simples, onde temos os atributos Id, Modelo e Placa.

Agora teremos a classe EstudoJSON

package br.com.json;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class EstudoJSON {
    public static void main(String[] args) throws JSONException {
        adicaoSimplesDeDados();
    }
}

Repare que criamos o método adicaoSimplesDeDados() que conterá o código de exemplo:

private static void adicaoSimplesDeDados() throws JSONException {
    //Criação do objeto carro e atribuição dos valores
    Carro carro = new Carro();
    carro.setId(1);
    carro.setModelo("Celta");
    carro.setPlaca("AAA1234");

    //Criação do objeto carroJson
    JSONObject carroJson = new JSONObject();
    //Inserção dos valores do carro no objeto JSON
    carroJson.put("id", carro.getId());
    carroJson.put("Modelo", carro.getModelo());
    carroJson.put("Placa", carro.getPlaca());

    //Impressão do objeto JSON
    System.out.println(carroJson);
}

Se executarmos este código, veremos que foi impresso no console o seguinte:

{"id":1,"Modelo":"Celta","Placa":"AAA1234"}

Você desenvolvedor mais atento vai reparar que existe um objeto impresso: Um Long! Isso mesmo! Como vimos, o JSON consegue armazenar objetos! Podemos inclusive armazenar um objeto do tipo Carro mesmo:

Modificamos o nosso método main:

public class EstudoJSON {
    public static void main(String[] args) throws JSONException {
        adicaoSimplesDeDados();

        adicaoDeUmObjeto();
    }
}

E adicionamos o método adicaoDeUmObjeto():

private static void adicaoDeUmObjeto() throws JSONException {
    Carro carro = new Carro();
    carro.setId(1l);
    carro.setModelo("Celta");
    carro.setPlaca("AAA1234");

    JSONObject carroJson = new JSONObject();
    //Adição do objeto carro
    carroJson.put("Carro", carro);

    System.out.println(carroJson);
}

Neste caso foi impresso no console o seguinte:

{"Carro":"[id=1, modelo=Celta, placa=AAA1234]"}

Simples não?

Como o JSON trabalha com coleção de pares nome/valor, podemos imprimir um valor específico simplesmente chamando o nome que desejamos.

System.out.println(carroJson.get("Modelo"));

Conclusão

É isso pessoal! Vimos as vantagens do JSON e vimos como é simples começar a trabalhar com ele.

Fonte: Alexandre Gama/devmedia

Tags | , , , ,

05

jan
2012

Sem Comentários

Em Blog
Python
Rails
Ruby

Por Allison

Como Ruby vem ganhando a prefrência do Python para administração de sistemas

Em 05, jan 2012 | Sem Comentários | Em Blog, Python, Rails, Ruby | Por Allison

Há cerca de três anos, eu comprei o livro “Python for Unix and Linux System Administration“, e ele me convenceu de que o Python seria a linguagem padrão de scripts para administradores do sistema Linux no futuro próximo. Eu estava trabalhando no projeto One Laptop Per Child (Um Laptop Por Criança) na época, onde o Python era a linguagem comum. Parecia que o Red Hat estava usando o Python para quase todo novo projeto. Além disso, o Unladen Swallow estava fazendo um progresso rápido. Eu não poderia estar mais errado.

Através de uma combinação de acidente histórico e algumas diferenças de recursos aparentemente pequenas, o Ruby está, inexoravelmente, se tornando a linguagem padrão dominante para a administração do sistema Linux.

Antes de eu ir mais adiante, seus administradores de sistema estão provavelmente gritando “Nós já temos uma linguagem de scripts, Bash!”. Mesmo amando Bash e commandlinefu, o Bash se torna uma obrigação, não uma qualidade quando seu script excede 100 linhas, e um completo pesadelo se você precisa analisar ou dar saída em HTML, CSV, XML, JSON etc.

Acidentes históricos

Em 2004, Luke Kanies falou sobre a construção do Puppet, um sistema de gerenciamento de configuração para melhorar as deficiências que ele via na CFEngine. Do excelente blog On Ruby:

Eu tentei implementar minha ideia em Perl, mas eu simplesmente não conseguia fazer os relacionamentos de classe funcionar (todos atributos e tipos de recursos precisavam ser classes, de acordo com o design na minha cabeça). Isso era quando o Python era o melhor, então eu naturalmente o experimentei, mas o Python simplesmente faz meus olhos sangrarem (e não, não era o espaço em branco, eram coisas como o fato de que `print` era uma instrução em vez de uma função, e `len` era uma função ao invés de um método).

Eu tinha um amigo que tinha ouvido falar que o Ruby era legal, mas não tinha de fato testado. Como eu estava simplesmente à toa na época, pensei em dar uma olhada. Quatro horas depois, nunca tendo visto uma linha de Ruby antes, eu tinha um protótipo funcional.

Dois anos depois, muitos desenvolvedores Puppet sentiram que o Puppet não satisfazia suas necessidades. Eles começaram suas própria ferramenta de configuração de gerenciamento, Chef, largamente inspirada pelo Puppet. A grande diferença entre Puppet e Chef é que Chef utiliza Ruby puro como “receita”, enquanto o Puppet usa sua própria linguagem de configuração baseada no Ruby.

Ambos Puppet e Chef estão sendo adotados rapidamente por grandes empresas, de acordo com a BusinessWeek. Se você ainda não estiver usando Puppet ou Chef, você deve começar a planejar a usá-los no futuro. Seja escolhendo Chef ou Puppet, você terá efetivamente o script da sua infraestrutura em Ruby. Depois de gastar 25% do seu tempo trabalhando com Puppet, você estará muito mais inclinado a escolher o Ruby para sua própria tarefa de scripting.

Projetos populares


Aqui está uma lista não definitiva de projetos sysadmin/devops em ruby

  • puppet
  • chef
  • vagrant
  • mcollective
  • cucumber (behavior-driven testing)
  • capistrano
  • rake (ruby Make)
  • aeolus project/openshift
  • cloud foundry
  • graylog2
  • logstash
  • travis-ci

e em Python:

  • openstack
  • cobbler
  • fabric
  • func
  • buildbot

O que é importante aqui não é o comprimento das respectivas listas, mas a importância dos projetos individuais. Chef, Puppet e Vagrant são os novos martelos e chaves-de-fenda da administração de sistemas. Se você for um administrador de sistema e ainda não está usando essas ferramentas, não se preocupe, você irá, cedo ou tarde.

O Openstack merece uma atenção especial, e é um projeto muito animador, mas ainda está no seu estágio inicial. Ele pode representar um papel importante no seu futuro como administrador do sistema.

Por favor, me notifique de projetos devops significantes que estão faltando nessa lista.

O que um administrador de sistema quer

Aqui estão os recursos em uma linguagem script que um administrador de sistema quer:

  • Um DSL para o problema do domínio
  • Alta produtividade, por exemplo, sintaxe expressiva e concisa
  • Fácil interação com comandos shell
  • Expressões regulares
  • Comandos de linha poderosos

Note que desempenho não está na lista de necessidades. O Ruby é acentuadamente mais lento que o Pyhton, e isso era particularmente verdade para a série 1.8.* do Matz Ruby Interpreter (MRI). No entanto, desempenho simplesmente não é algo crítico para 90% do nosso trabalho como administradores de sistema. Nós nos importamos mais com produtividade do que com desempenho. Legibilidade é legal, mas está um segundo distante de produtividade.

O Python não tem expressões regulares nativamente, provavelmente para melhorar a legibilidade. Ele também limita o número de variáveis globais de alto nível embutidas. De uma perspectiva de design de linguagem, isso é muito mais limpo. Da perspectiva do seu administrador de sistema padrão, treinado na rua, estressado, viciado em VI, é irritante.

Essas variáveis de alto nível também deixam as ONE_LINERS mais concisas. Aqui estão algumas.

$_ last line read from STDIN
$? last exit code from a child process
$stdin reference to stdin
$stderr reference to stdout
$stdout reference to stdout

Aqui está uma sessão IRB para mostrar esses valores em ação.

hitman@hiroko:~/pr$ irb
irb(main):001:0> %x[ ls -a ]
=> ".\n..\nfoo1\nfoo2\nfoo3\n"
irb(main):002:0> puts $?
0
=> nil
irb(main):003:0> %x[ ls xys ]
ls: cannot access xys: No such file or directory
=> ""
irb(main):004:0> puts $?
512
=> nil

“IRB?” você me zomba, “Você terá que arrancar o IPython das minhas mãos mortas geladas.”

Eu adoro o IPython. Eu usei o IPython por mais de quatro anos, e o IRB não tem comparação a ele. Dito isso, os atalhos do Ruby são bastante úteis, o suficiente pra compensar as deficiências do IRB. Existe algo chamado wirble que eu ainda não tentei, mas ele pode deixar o IRB bem mais produtivo.

Aqui está algum código Python para detectar se uma máquina é VMware VM.

# edit: fixed python code tks to kstrauser

import os
  if 'vmware' in os.popen('dmidecode').upper():
    print 'this is a vmware vm'
  else:
    print 'this is not a vmware vm'

Aqui está o mesmo código em Ruby:

`dmidecode`
if $_ ~= /vmware/i
   puts 'this is a vmware vm'
else
   puts 'this is not a vmware vm'

Francamente, esse tipo de código faz meus olhos sangrarem. O exemplo do Python é muito mais legível e mais fácil de manter. Dito isso, muitos dos administradores de sistema iriam gostar de quão conciso é o exemplo do Ruby.

Vamos ver como escrever comandos de linha em ambas as linguagens.

O código imprime as primeiras 10 linhas em um arquivo usando Python.

python -c "import sys; sys.stdout.write(''.join(sys.stdin.readlines()[:10]))" < /path/to/your/file

Aqui está o mesmo código em ruby:

ruby -ne 'puts $_ if $. <= 10 ' < /path/to/your/file

Compare você mesmo essas coleções de oneliners no Python e no Ruby. Se o Ruby te lembra o Perl, seus olhos não te enganam. Em muitas maneiras, ele é o filho querido do Perl e do Smalltalk.

DSLs FTW

Há algum tempo, eu tentei assistir a todas as palestras da Structure and Interpretation of Computing. Todo esse esforço falhou miseravelmente, mas eu me lembro de Harold Abelson dizendo que todo grande programa deveria ter seu próprio DSL interno adequado para o problema de espaço. Isso é debatível devido ao grande mundo da programação, mas eu acredito estar apto para a administração de sistemas. Passamos toda nossa carreira com vários DSLs diferentes. Cada formato de arquivo com configuração diferente é seu próprio DSL.

Se você comparar o rake (Ruby Make) ao código rails, eles parecem muito diferentes, quase linguagens diferentes. Se você comparar o código fabric a uma classe django, eles se parecem muito. Isso é uma força e uma responsabilidade. Não sou nenhum advogado de linguagem, mas parece muito mais fácil criar DSLs (Domain Specific Languages). O Ruby certamente gera DSLs com uma frequência muito maior do que o Python. Nenhuma ferramenta de construção do Python domina o problema de espaço como o rake faz na comunidade Ruby. A maioria dos projetos Python parece usar setup.py para tarefas administrativas, mesmo este não sendo seu objetivo explícito.

Ambos, Puppet e Chef são DSL para administração de sistemas. O Capistrano é uma DSL para deploy de aplicações. Sobrecarga de operadores e os blocos do Ruby facilitam a criação de DSLs.

Em resumo

A maior força do Ruby é sua grande flexibilidade. Existe muita “mágica” no Ruby, e às vezes essa magia é negra. O Python intencionalmente tem o mínimo de mágica. Sua maior força é a capacidade de reforçar as boas práticas através da sua comunidade. Essas práticas tornam o Python bastante legível em vários projetos. Eles garantem alta qualidade de documentação, fazendo sua biblioteca padrão arrasar. Mas o fato é que nós sysadmin precisamos de flexilidade mais do que precisamos de poder ou consistência. Mesmo assim, esses não são os motivos reais pelos quais o Ruby está tomando o lugar do Python.

O Ruby está rapidamente se tornando a linguagem de script para os administradores de sistema porque, em 2004, Luke Kanies olhou para o Python e se sentiu doente (eu tive a reação oposta). Como um administrador de sistema, você ou está ou logo estará usando o Puppet ou o Chef diariamente, gastando muito tempo essencialmente codificando em Ruby. Pessoalmente, eu prefiro em Python, mas estou mudando a escrita dos meus scripts para Ruby porque passo muito tempo no Chef.

Texto original em inglês de Bryan Berry, disponível em http://devopsanywhere.blogspot.com/2011/09/how-ruby-is-beating-python-in-battle.html

Fonte: Bryan Willson Berry/IMasters

Tags | , , , , , ,

17

dez
2011

Sem Comentários

Em Blog
Wordpress

Por Allison

Como Criar ou Recuperar um Backup de seus Posts no Blogger

Em 17, dez 2011 | Sem Comentários | Em Blog, Wordpress | Por Allison

Assim como acontece com nossos computadores, os servidores de hospedagens também estão suscetíveis a problemas diversos, como arquivos corrompidos, problemas com os bancos de dados ou mesmo uma invasão, que podem levar a perda dos dados de todos os sites armazenados. Por isso é importante sempre ter uma cópia de segurança de todo o conteúdo publicado em nossos sites e blogs para o caso de alguma catástrofe.

É necessário criar cópias de segurança no Blogger

Embora o Blogger não tenha a fama de apresentar problemas com seus servidores, algumas pessoas tem reclamado de que seus blogs foram excluídos sem explicação clara, o que é um problema que poderia ser amenizado com uma cópia de todos os posts, já que desta forma seria possível recuperar pelo menos o conteúdo.

Além disso a cópia de segurança também pode ser útil para quem pensa em mudar de blog, já que a cópia poderia ser utilizada para transferir o conteúdo de um blog para outro, inclusive do Blogger para WordPress.

Se você usa o WordPress, confira o artigo “Crie cópias de segurança de seu blog WordPress“.

Como exportar o blog no Blogger

Se você tem um blog no Blogger e deseja criar uma cópia de segurança de seu conteúdo, acesse o painel de controle e clique na aba “Configurações“. Lá você encontrará as opções “Importar Blog“, “Exportar Blog” e “Excluir Blog“.

Clique em “Exportar Blog” e na nova página clique no botão “Fazer Download do Blog” para iniciar o download de um arquivo XML que contém os posts de seu blog.

Como importar o blog

Se você precisa recuperar uma cópia por qualquer motivo, você deve acessar o painel de controle, clicar em “Configurações” e desta vez clicar em “Importar Blog“.

Na janela que aparece selecione o arquivo que você exportou anteriormente em seu computador, digite a palavra anti fraude que apare e clique no botão “Importar Blog“.

Dicas

Para manter seu blog seguro é recomendado que você faça backups periódicos dependendo da frequência com que você publica seus posts, desta forma você mantém sempre uma cópia com os últimos posts publicados.

Para quem pretende importar posts de outro blog, lembre-se de que o Google está penalizando sites e blogs com conteúdo duplicado (cópia). Portanto se pensa em fazer isso, recomendo que apague o blog antigo depois de fazer a transferência.

Se pretende excluir seu blog, tenha em mente que não poderá voltar atrás.

Nota

Vi a dica deste artigo no Life Find no artigo “Fazendo o backup do layout e das postagens no Blogger“.

Fonte: Celso Lemes/CriarSites

Tags | , , , ,

02

dez
2011

Sem Comentários

Em Blog
Java
Testes

Por Allison

Restfuse 1.0.0: uma biblioteca para facilitar testes de integração REST/HTTP

Em 02, dez 2011 | Sem Comentários | Em Blog, Java, Testes | Por Allison

A EclipseSource lançou a primeira versão estável de uma extensão open souce do JUnit para automação de testes de serviços REST/HTTP. O Restfuse é um conjunto de anotações para JUnit que oferece asserções para respostas de requisições HTTP. Tanto chamadas síncronas como assíncronas são suportadas.

O Restfuse já está disponível no Maven Central, então para usá-lo não é necessário nenhum repositório especial:

<dependency>
<groupId>com.restfuse</groupId>
<artifactId>com.eclipsesource.restfuse</artifactId>
<version>1.0.0</version>
</dependency>

Usar a biblioteca para chamadas síncronas é simples e direto:

@RunWith(HttpJUnitRunner.class)
public class RestFuseTest {
@Rule
public Destination destination = new Destination("http://example.com" );

@Context
private Response response; // será injetado depois de cada chamada
@HttpTest(method = Method.GET, path = "/reloadLocalConfiguration" )
public void checkRestfuseOnlineStatus() {
assertOk(response );
String answerBody = response.getBody(String.class);
assertEquals("Expected correct response","done",answerBody);
}
}

O teste acima chama um endereço HTTP de maneira síncrona e então valida se há uma resposta textual (text/plain) contendo a string “done”. Note que a primeira asserção, assertOk, é do Restfuse; ela verifica se o status da resposta HTTP foi 200 OK. A segunda asserção, assertEquals, verifica a igualdade como no JUnit. Embora esteja se supondo que o endereço HTTP vai retornar um texto puro, poderia também ser processado conteúdo em JSON/XML ou de outro tipo, e executar os asserts de maneira estruturada.

O Restfuse também suporta chamadas assíncronas. Uma aplicação clássica disso se dá em operações de longa duração (como o upload de um arquivo extenso), em que o cliente monitora continuamente o servidor para identificar o status atual. No exemplo abaixo, é considerado um endereço do lado servidor que retorna um número entre 0 e 100 e mostra o progresso de alguma operação:

@RunWith( HttpJUnitRunner.class )
public class PollTest1 {

@Rule
public Destination destination = new Destination( "http://example.com" );

@Context
private Response response;

@Context
private PollState pollState;

@HttpTest( method = Method.GET, path = "/progressStatus" )
@Poll( times = 5, interval = 500 )
public void testAsynchronousService() {
if(pollState.getTimes() == 5)
{
String answerBody = response.getBody(String.class);
assertEquals("Expected last response","100",answerBody);
}
}
}

O teste acima chama o mesmo endereço cinco vezes (com um intervalo definido), mas somente a última chamada verifica a resposta HTTP.

Uma característica interessante da interface PollState é a manutenção das respostas anteriores. Isto permite aos asserts sejam feitos sobre o histórico das chamadas:

@RunWith( HttpJUnitRunner.class )
public class PollTest2 {

@Rule
public Destination destination = new Destination( "http://example.com" );

@Context
private Response response;

@Context
private PollState pollState;

@HttpTest( method = Method.GET, path = "/progressStatus" )
@Poll( times = 5, interval = 500 )
public void testAsynchronousService() {
int currentRun = pollState.getTimes();
if(currentRun > 1)
{
String previousProgress = pollState.getResponse(currentRun - 1).getBody(String.class);
String presentProgress = response.getBody(String.class);
assertTrue("Expected some progress",Integer.parseInt(presentProgress) > Integer.parseInt(presentProgress)); //Just for illustration purposes
}
}
}
}

O teste acima verifica se cada resposta tem número superior à resposta anterior. O Restfuse tem uma dependência com o servidor HTTP Jetty e suporta serviços assíncronos que seguem o modelo de Web Hooks. Ao invés de enviar várias requisições ao servidor para verificar o estado de um processo, o cliente cliente faz uma chamada uma única vez e então aguarda por uma resposta iniciada pelo servidor em uma conexão diferente. Aqui está um exemplo usando Restfuse:

 
@RunWith( HttpJUnitRunner.class )
public class RestfuseCalbackTest {

@Rule
public Destination destination = new Destination( "http://example.com" );

@Context
private Response response;

private class TestCallbackResource extends DefaultCallbackResource {

@Override
public Response post( Request request ) {
assertTrue("Expected a quote response", request.getBody(String.class).startsWith("quote:") );
return super.post( request );
}
}

@HttpTest( method = Method.GET, path = "/requestQuote" )
@Callback( port = 9090, path = "/asynchron", resource = TestCallbackResource.class, timeout = 10000 )
public void testMethod() {
assertAccepted( response );
}
}

Este último exemplo conecta-se ao requestQuote e monitora a porta 9090 do cliente. Durante até dez segundos, ele espera uma resposta textual, começando com “quote:”

Para mais informações sobre o Restfuse, visite a wiki do projeto e seu Javadocs. O código-fonte esta hospedado no GitHub.

Fonte: Kostis Kapelonis , traduzido por Jefferson Prestes /InfoQ

Tags | , , , , , , ,

23

nov
2011

Sem Comentários

Em Blog
NodeJs

Por Allison

NodeJS – análise e processamento de grandes documentos XML

Em 23, nov 2011 | Sem Comentários | Em Blog, NodeJs | Por Allison

Se você está trabalhando com dados legados, muitas vezes deve ter problemas com o tamanho dos dados. Um tempo atrás, eu tive que analisar grandes arquivos XML, extrair alguns dados, convertê-los, adicionar manualmente os dados gerados e então salvar o output em um arquivo JSON. (Precisamos disso porque mais tarde esse arquivo será usado como input para nosso componente ExtJS/Sencha).

Na minha máquina de desenvolvimento, o NodeJS já está instalado. Dê uma olhada no guia de instalação NodeJS, se você quiser instalá-lo. Agora você pode escrever programas executáveis em JavaScript baseados no mecanismo V8 do Google.

Eu fiz o download da SAX XML parser library para o NodeJS (escrita por isaacs). É bastante fácil incluí-la no meu espaço de trabalho, apenas adicione uma linha simples para incluir “sax.js”. O segundo componente de que preciso é o arquivo do sistema para ler o conteúdo do arquivo XML.

var fs = require('fs');
var sax = require('./sax');

A primeira coisa que você tem que fazer é criar uma nova instância do parser.

parser = sax.parser(strict);

O parser sozinho está trabalhando orientado a eventos, como quase tudo no NodeJS. Quando você está usando um parser orientado a eventos XML, é bastante útil usar um diagrama de estados – pois é mais fácil compreender o tipo de nó que você está visitando atualmente.

Agora existem alguns ganchos pré-definidos que você pode usar para escutar eventos como open tag, close tag etc…

parser.ontext = function(t) {
   console.log('This is the text in that node: ' + t);
};

parser.onopentag = function(node) {
   //on new tag opened
};

No final, a única coisa que você tem que fazer é iniciar o processo do parser. Apenas leia o conteúdo do arquivo em um String buffer (chamado file_buf) e então o coloque na biblioteca do parser.

try {
    var file_buf = fs.readFileSync('./demistified.xml');
    parser.write(file_buf.toString('utf8')).close();
} catch(ex) {
    // keep 'em silent
}

Nos ganchos do evento, você pode começar a escrever sua própria estrutura de dados, o NodeJS é construído para analisar e segurar muitos dados complexos. No meu caso, eu tinha um arquivo de 20 MB de dados XML, e eu extraí 180 nós de dados dessa imensa quantidade em apenas 2 segundos.

No final, se você precisar que sua estrutura interna de dados (provavelmente você usará array e combinações de objetos) seja salva em um arquivo, você pode facilmente utilizar o comando:

fs.writeFileSync('test.json', JSON.stringify(DataNodeSpace));

Ele escreve o array DataNodeSpace no formato JSON no arquivo test.json.

Para modificar, atravessar, adicionar propriedades a um array ou objeto no JavaScript ou no NodeJS, é bastante fácil e rápido. Eu fiquei maravilhado com a rapidez com que você pode construir um parser XML (10 linhas de código) e depois da (mais ou menos complexos *g*) execução dos algoritmos de análise você pode transformar os elementos de dados fácil e confortavelmente.

Espero que você tenha tido uma pequena visão geral sobre como analisar arquivos XML no NodeJS.

Texto original disponível em http://blog.lagentz.com/nodejs/nodejs-parsing-and-transforming-large-xml-documents/

Fonte: IMasters

Tags | , , ,

21

nov
2011

Sem Comentários

Em Blog

Por Allison

Prós e Contras do WordPress e Blogger

Em 21, nov 2011 | Sem Comentários | Em Blog | Por Allison

O WordPress e o Blogger são duas das plataformas mais utilizadas na criação de blogs, cada um com suas vantagens e desvantagens, que devem ser levadas em consideração por quem deseja iniciar um novo blog.

Abaixo você pode conferir uma lista com as principais vantagens e desvantagens oferecida por cada uma destas duas plataformas, que podem te ajudar na hora de iniciar um novo projeto.

WordPress

O WordPress oferece duas versões de sua plataforma, sendo uma que pode ser criado facilmente no WordPress.com e também um pacote que pode ser baixado no WordPress.org e instalado em um servidor apropriado.

Basicamente, a diferença entre os dois está no fato de que o WordPress.com é mais limitado, não permitindo editar ou instalar novos templates, adicionar novos plugins ou adicionar publicidades, enquanto que no WordPress instalado você tem muito mais liberdade para fazer tudo isso.

Prós do WordPress:

wordpressTemplates

WordPress.org – Permite adicionar novos templates e também editá-los de uma forma mais fácil em relação ao Blogger.

WordPress.com – Não permite adicionar ou editar templates.

Plugins

WordPress.org – Permite adicionar novos plugins que dão mais funcionalidades a plataforma, como é o caso de contadores de visitas, melhoramentos na navegação, backups automáticos, sistemas de newsletter e etc.

WordPress.com – Tem um número limitado de plugins e não permite adicionar plugins novos.

Proteção por senha

WordPress.org e WordPress.com – Permitem proteger qualquer página ou post com uma senha, impedindo que qualquer pessoa tenha acesso ao conteúdo.

Maior controle sobre os dados do blog

WordPress.org – Você tem acesso total ao banco de dados e os arquivos que compõem o blog, o que dá liberdade para ter uma cópia local de seu blog e movê-lo para outra hospedagem a qualquer momento. Você é dono do seu conteúdo.

WordPress.com – Não permite acessar os arquivos ou o banco de dados. No entanto, isso só seria um problema caso seu blog esteja fora das diretrizes de uso do próprio WordPress, que neste caso poderia deletar a sua conta.

URLs amigáveis

WordPress.org e WordPress.com – O WordPress permite customizar a URL dos posts e páginas, tornando mais amigáveis para os buscadores.

SEO

WordPress.org e WordPress.com – O WordPress por si só já é melhor em relação a SEO e fica melhor ainda depois de instalar alguns plugins como o All in One SEO Pack, que oferece uma melhor customização dos títulos dos posts (que aparece no topo dos navegadores), meta tags, descrição e etc.

Empresas de hospedagens oferecem a instalação do WordPress com 1 clique

WordPress.org – Quem deseja optar pelo WordPress instalado, poderá usufruir do sistema de auto instalação oferecido pela maioria das empresas de hospedagem de sites.

Criação de páginas infinitas

WordPress.org e WordPress.com – O WordPress permite criar páginas estáticas infinitas, ao contrário do Blogger que atualmente só permite adicionar 20.

Contras do WordPress:

Maior conhecimento técnico

WordPress.org – Um blog instalado exige maior conhecimento sobre os procedimentos relacionados a publicação de arquivos, preparação do banco de dados e instalação do WordPress, o que não acontece no Blogger ou no WordPress.com

Não é de graça

WordPress.org – Para ter um blog instalado é necessário adquirir uma hospedagem profissional (as hospedagens grátis não são recomendadas) e 1 domínio próprio, o que pode custar algo em volta de R$15,00 por mês.

Mais responsabilidades

WordPress.org – Para que seu blog esteja seguro, é necessário que você cuide de realizar backups periódicos para se prevenir em caso de uma catástrofe. Além de estar encarregado de verificar se tudo está funcionando corretamente com o servidor de hospedagem.

Publicidade

No WordPress.com é proibido a inclusão de qualquer tipo de publicidade, tanto é que as publicidades do Google Adsense não aparecem de jeito nenhum no blog.

Blogger

O Blogger é uma plataforma oferecida gratuitamente pelo Google, que também permite criar blogs incríveis, mas que não são tão bons em relação a customização e otimização para os buscadores.

É Grátis

Desde que você opte pelo subdomínio grátis (seublog.blogspot.com), você não precisa pagar nada, mas se quiser adquirir um domínio, terá que desembolsar $10 por ano.

Templates grátis

O Blogger também conta com centenas de templates grátis.

Não precisa se preocupar com backup

O próprio Google se encarrega de cuidar do backup de seus arquivos e do banco de dados.

É mais fácil para se cadastrar no Google Adsense

Quem tem uma conta no Blogger, tem mais facilidade para criar uma conta no Google Adsense para ganhar dinheiro com o blog.

Proteção por senha

O Blogger apenas permite adicionar um usuário e senha para o blog que abrange o blog todo, diferente do que acontece com o WordPress que permite proteger páginas individuais.

Contras do Blogger:

Não permite armazenar outros tipos de arquivos

O Blogger somente oferece a hospedagem de imagens. Se precisar armazenar outros tipo de arquivos, terá que utilizar serviços de armazenamento oferecidos por terceiros. No WordPress.org você não tem este tipo de problema.

Não oferece categorias

O Blogger não permite organizar o conteúdo por categorias como acontece no WordPress. A única forma de organizar o conteúdo por seções é através dos marcadores, que são conhecidos por TAGS no WordPress.

Não permite editar comentários

Você não pode editar os comentários deixados pelos visitantes.

Não permite editar a URL dos posts

A URL dos posts não pode ser editada.

Não permite adicionar meta tags individuais

Você somente tem a opção de adicionar meta tags de uma forma generalizada, que aparece igual em todos os posts e páginas do blog.

Não permite editar os títulos

O Blogger não permite adicionar um título para as páginas (que aparece no topo dos navegadores) diferente dos títulos dos posts, o que pode atrapalhar um pouco a otimização do blog.

Reputação ruim

De uma forma geral, o Blogger tem uma má reputação devido aos montes de blogs spams que são criados diariamente. O que pode levar muitas grandes empresas a bloquearem o acesso de seus funcionários a qualquer blog que utilize um subdomínio oferecido pelo Blogspot.com.

Templates com código sujo

Os templates do Blogger em sua maioria contém códigos desnecessários e também carregam todo o CSS dentro do mesmo arquivo XML, o que aumenta o tempo de carregamento do blog e pode prejudicar no posicionamento do blog nos buscadores.

Conclusões

Para resumir, eu diria que o Blogger é mais recomendado para quem deseja criar um blog pessoal ou mesmo que pretenda criar um blog profissional, mas ainda não tem certeza de que dará continuidade no projeto. Digo isso porque a maioria dos blogueiros abandonam seus blogs nas primeiras semanas.

Se depois de uns 3 meses, ainda estiver trabalhando firme na criação de conteúdo para seu blog, recomendo que mude para o WordPress, pois as chances de ter sucesso são maiores. Se este for o seu caso, recomendo que leia o artigo “Como transferir o Blogger para o WordPress“.

Fonte: Celso Lemes/CriarSites

Tags | , , , , , , , , ,

13

nov
2011

Sem Comentários

Em Blog

Por Allison

Usando Ajax com jQuery

Em 13, nov 2011 | Sem Comentários | Em Blog | Por Allison

Realmente eu achava chato programar em javascript, algo complicado, cheio de lerolero, mas então eu encontrei o jQuery, e programar em javascript se tornou algo fácil e muito divertido. Realmente eu fiquei muito feliz a descobrir este framework (se é que pode ser chamado assim). Hoje vou falar de uma das funcionalidades mais uteis e mais requisitadas que podemos usar para sistemas web, o ajax.

Tirando da Wikipedia: AJAX (acrônimo em língua inglesa de Asynchronous Javascript And XML) é o uso metodológico de tecnologias como Javascript e XML, providas por navegadores, para tornar páginas Web mais interativas com o usuário, utilizando-se de solicitações assíncronas de informações. Mas na linguagem mais simples, conseguimos fazer uma requisição a um arquivo (pagina) sem precisar fazer reload de tela. Sim, isto torna muito mais rápido a execução do seu código, e muito mais bonito e elegante tbm.

Uma coisa que vamos aprender como jQuery é que vamos separar totalmente o nosso código javascript do nosso html. Gosto de pensar a programação web em camadas, sendo elas: conteúdo (html), estilo (css) e ação (javascript). Ainda temos a tomada de decisão (php), mas acho que falar sobre isto é coisa para outro tutorial. Vamos ao que interessa.

Primeiro, precisamos baixar o jQuery direto da fonte: http://docs.jquery.com/Downloading_jQuery

Vamos entender como funciona a estrutura básica:

<!doctype html>
<html>
  <head>
    <!-- aqui vamos fazer o nosso include da biblioteca do jQuery -->
    <script type="text/javascript" src="jquery.js"></script>
 
    <script type="text/javascript">
      <!-- aqui vamos escrever nosso código javascript -->
    </script>
  </head>
  <body>
    <a href="http://jquery.com/">jQuery</a>
  </body>
</html>

Muito simples, fizemos a requisição do nosso arquivo jQuery, e logo em seguida escrevemos nosso código entre as tags .

Mas vamos agora ao nosso código:

<!doctype html>
<html>
  <head>
 
    <script type="text/javascript" src="jquery.js"></script>
 
    <script type="text/javascript">
    $(document).ready(function(){
      $("#button_busca").click(function () {
        $("form").submit(function () { return false; });
        var busca = $("#busca").val();
        $.ajax({
            type: "POST",
            url: "busca.php",
            data: "busca="+busca,
            success: function(html){
                $("#resposta").html(html);
            }
        });
    });
    });
    </script>
  </head>
  <body>
    <div id="resposta"> </div>
    <form>
    <fieldset>
        <legend>Busca</legend>
        <dl>
            <dt><label for="busca">Palavra Chave:</label></dt>
            <dd><input type="text" name="busca" id="busca" /></dd>
        <dd class="botao"><button id="button_busca">Busca</button></textarea></dd>
            </dl>
    </fieldset>
    </form>
  </body>
</html>

Primeiro fazemos o include da biblioteca jQuery. Depois temos a linha: “$(document).ready(function(){” isto faz com que assim que a pagina termine de ser carregada ele aplique as rotinas que vamos escrever abaixo dele. Abaixo temos “$(“#button_busca”).click(function () {” que vai associar ao id button_busca uma ação quando ele for clicado.

Usamos a função “$(“form”).submit(function () { return false; });” para que quando o botão for clicado ele não faça um reload de tela enviando para a action do form.

Criamos uma variável e atribuímos a ela o valor que estiver no campo de input com o id busca (“var busca = $(“#busca”).val();”).

A nossa chamada ajax ocorre na linha 13, onde chamamos a função e passamos os parâmetros:

  • type: tipo de encoding que vai ser enviado para o arquivo.
  • url: caminho completo do arquivo que vai ser requisitado.
  • data: os valores que serão passados, no nosso exemplo estão passando a variável busca, com o valor que pegamos do input com o id busca.
  • success: dizemos que caso tudo funcione ok, execute isto, no nosso caso estamos pegando o retorno da requisição e jogando o mesmo como html na div de id resposta.

Segue ainda o código php:

<?php
       echo "Resultado da Consulta aqui: $_POST[busca]";
?>

Fonte: Rafael Cirolini/NerdHead

Tags | , , , , , ,

12

nov
2011

Sem Comentários

Em Blog

Por Allison

Utilizando JSON em projetos iBOLT e uniPaaS

Em 12, nov 2011 | Sem Comentários | Em Blog | Por Allison

O padrão de notação JSON (“JavaScript Object Notation” http://en.wikipedia.org/wiki/JSON) tem sido bastante utilizado na troca de informações entre aplicações WEB atualmente, isto porque existem alguns ganhos como quantidade de bytes se comparado com XML (http://en.wikipedia.org/wiki/JSON#Comparison_with_other_formats) e o fato de não ser necessário a utilização de parse mais apurado como XML.

Como em nossa tecnologia (iBOLT e uniPaaS) existe a grande facilidade de trabalhar com XML, que tal convertermos JSON para XML? A idéia deste post é se utilizar de um componente JAVA já desenvolvido para o tratamento de JSON e incluir em nossa solução um componente reutilizável para iBOLT e invocar este código JAVA no uniPaaS.

As referências do nosso post são:

1) http://json.org: Descrição de toda notação JSON

2) http://json.org/java/: Código Java que iremos utilizar em nossa solução iBOLT e uniPaaS

3) http://download.oracle.com/javase/6/docs/technotes/tools/windows/javac.html: Como compilar o código extraído do item 2

4) http://download.oracle.com/javase/6/docs/technotes/tools/windows/jar.html: Como gerar o arquivo .jar para ser incluído na biblioteca do iBOLT e uniPaaS

5) http://devnet.magicsoftware.com/en/library?book=en/uniPaaS/&page=Java_Integration/Type_Signatures.htm: Como saber a assinatura de um objeto JAVA para ser utilizado em uniPaaS.

Preparando nossa biblioteca escrita em JAVA

Faça o download do código fonte que está no item 2 da nossa referência. Neste exemplo colocarei na pasta C:\POST, para seguir a estrutura do JAVA. Como o código foi desenvolvido dentro de um pacote org.json, coloque os arquivos dentro de uma estrutura de pasta org\json, então coloque todos os arquivos no caminho C:\POST\org\json. Veja como ficou nossa estrutura:

Para facilitar o nosso teste no iBOLT e uniPaaS, vamos criar um novo código JAVA, este código fará a conversão do objeto JSON em XML e vice-versa.

Crie um novo arquivo chamado Conversor.java e inclua o seguinte código:

Agora vamos compilar todos estes arquivos *.java, executando simplesmente o comando javac *.java, veja como foi o resultado:

Agora vamos juntar todos os *.class em um único pacote, basta ir para a pasta C:\POST e rodar o comando jar -cvf json.jar org\json\*.class, veja como foi o resultado:

Pronto na pasta C:\POST foi gerado o arquivo json.jar que vamos utilizar no iBOLT e uniPaaS.

Utilizando em iBOLT

Como o iBOLT tem a possibilidade de expandir a capacidade de sua lista de componentes, utilizando o item componente SDK (http://devnet.magicsoftware.com/en/library?book=en/iBOLT/&page=Component_SDK.htm) vamos incluir um novo componente que será capaz de converter um formato JSON para XML e ao contrário.

Pegue o arquivo json.jar gerado no item anterior e coloque na pasta <ibolt_home>\java\lib.

Acesse o menu Tools / Component SDK e clique em New. Coloque as seguintes informações na tela:

Repare que o tipo é Java, e para ficar mais interessante copiei a imagem de http://json.org/img/json160.gif para <ibolt_home>icons\jsonifc.gif.

Clique em Methods e digite org.json.Conversor no campo class name, ao teclar tab aparecerão os métodos. Selecione somente os métodos toXML e toJSON. Veja:

Após clicar em load abrirá uma tela para melhorar a forma de configurar o nosso componente, neste passo é interessante colocar nomes amigáveis em Display Name, neste sentido vamos fazer as seguintes alterações:

No método toJSON, no parâmetro P1 colocar o display name para XML e no parâmetro P_Return colocar o display name para JSON. Em ambos os parâmetros altere o campo Picture para 32000.

No método toXML, no parâmetro P1 colocar o display name para JSON e no parâmetro P_Return colocar o display name para XML. Em ambos os parâmetros altere o campo Picture para 32000.

Clique em OK.

Para gerar o nosso componente e ser possível sua utilização clique em Generate e depois OK e pode fechar a tela atual.

O componente definido nos passos anteriores fica gravado na pasta <ibolt_home>\User resources\Components onde cada pasta significa um componente definido na tela do Componente SDK.

Sempre que precisar utilizar nos projetos o componente colocado no componente SDK você deve acionar o menu Project / Component clicando no botão Add.

Agora já temos um novo componente na lista de componente do iBOLT. Veja:

Agora podemos configurar os métodos, veja:

Observações que devem ser sempre seguidas em ambiente desenvolvimento e produção que utilizarem o componente em questão:

1) O arquivo json.jar deve estar sempre no caminho <ibolt_home>\java\lib

2) O componente SDK deve estar sempre na pasta <ibolt_home>\User resources\Components

Utilizando em uniPaaS

Para o uniPaaS carregar o arquivo json.jar criado anteriormente teremos que acrescentar no magic.ini na seção [MAGIC_JAVA] na configuração CLASSPATH o local onde o uniPaaS poderá encontrar o arquivo json.jar. Neste sentido iremos disponibilizar o arquivo json.jar em uma pasta na própria instalação do uniPaaS no local C:\MSE\uniPaaS1.9h\json por exemplo, veja:

Precisamos alterar no magic.ini na seção [MAGIC_JAVA] na configuração CLASSPATH informando o arquivo json.jar. Veja:

Agora vamos fazer o programa que invoca o código JAVA, imaginando que tivéssemos uma tela desta forma:

A referência da variável JSON é igual a “A” e a referência da variável XML é igual “B”. Basta utilizar a função JCallStatic. Nesta função precisamos passar o nome da classe e método, assinatura e parâmetros. No nosso caso as informações são:

Nome da classe = org.json.Conversor.toXML

Assinatura = (Ljava/lang/String;)Ljava/lang/String; esta informação foi obtida utilizando a nossa referência do item 5.

O parâmetro = JSON que neste caso é a variável A.

Veja como fica nossa expressão:

A expressão acima está sendo utilizada em um update. Veja:

Executando e testando, veja que o objeto JSON é convertido em XML:

CONCLUSÃO

Com a implementação de uma nova funcionalidade em nossa ferramenta, colocamos em prática a possibilidade de interoperabilidade e aumento da capacidade em nossa ferramenta iBOLT e uniPaaS. Com isso, em um exemplo bem prático e simples colocamos a prova de como são simples e poderosas as nossas ferramentas.

Espero que este post tenha ajudado a enxergar no iBOLT e uniPaaS as ferramentas poderosas e versáteis que temos em nossas mãos.

Fonte: Jeronimo Costa/MagicSoftware

Tags | , , , , ,

28

out
2011

Sem Comentários

Em Blog

Por Allison

Google libera ferramenta de análise do JavaScript como projeto open source

Em 28, out 2011 | Sem Comentários | Em Blog | Por Allison

O Google anunciou que liberou o ScriptCover como um projeto open source. Disponível como uma extensão do navegador Chrome, o ScriptCover é uma ferramenta do JavaScript que oferece estatísticas em tempo real, linha a linha do código para os sites.

Além disso, o recurso disponibiliza resultados à medida que a página continua a ser carregada e é atualizado automaticamente quando o usuário interage com o site. A ferramenta destaca cada uma das linhas de código que foi executada para uma análise mais detalhada.

De acordo com Ekaterina Kamenskaya, engenheira de software do Google, o detector de cobertura de código é útil ao realizar testes manuais e automáticos e para compreender e debugar códigos complexos. Ela acrescentou que desenvolvedores acreditam que futuras versões do ScriptCover podem incluir suporte para outras métricas e relatórios mais completos, com opções de exportar para os formatos HTML e XML, assim como a capacidade de apresentar estatísticas de cobertura para um servidor para análise.

Mais detalhes sobre o ScriptCover podem ser encontrados aqui. Hospedada no Google Code, a ferramenta está sob a licença Apache Licence 2.

Texto originalmente publicado em The H

Fonte: IMasters

Tags | , , , , , , ,