Image Image Image Image Image
Scroll to Top

Topo

ruby

20

maio
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Como implementar uma aplicação Cliente-Servidor com Sockets em Ruby

Em 20, maio 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Samuel Vinicius/IMasters

Este é primeiro de vários artigos que irei publicar sobre Sockets em Ruby. Mas, antes de qualquer coisa, é conveniente dizer o que são Sockets:

A grosso modo, são as extremidades de um canal de comunicação bidirecional. Ou seja, você pode utilizar Sockets para fazer comunicação entre processos de uma máquina, entre máquinas diferentes e entre processos de máquinas diferentes.

O que iremos fazer?

Como este é o primeiro artigo sobre o tema, pretendo ir direto ao ponto, mostrando de forma simples como implementar uma aplicação Cliente-Servidor. Nessa aplicação, o cliente envia uma mensagem para o servidor e este responde, sendo a comunicação entre cliente e servidor realizada via Socket através do protocolo TCP.

Então, sem mais delongas, vamos aos códigos:

  • Servidor
 
# file server.rb
require 'socket'
 
server = TCPServer.open(3001)  # Abre socket em escuta na porta 3001
loop { # o servidor nunca morre, fica sempre executando
client = server.accept      # aceita conexão do cliente
msg_cliente = client.recvfrom( 10000 ) # recebe mensagem - 10000 bytes - do cliente
 
puts  "Mensagem do cliente: #{msg_cliente}" # imprime a mensagem do cliente no servidor
client.puts "Ola cliente eu, o servidor, recebi sua mensagem" #envia uma mensagem ao cliente
client.close # fecha conexão
}
  • Cliente
# file client.rb
require 'socket'
 
server = TCPSocket.open('localhost', 3001) # conecta ao servidor na porta 3001
server.puts "Ola servidor eu, o cliente, estou enviando uma mensagem" # envia mensagem para o servidor
 
resp = server.recvfrom( 10000 ) # recebe a mensagem -10000 bytes - do servidor
puts resp
 
server.close # Fecha a conexão com o servidor

Como rodar a aplicação?

Primeiro, salve o código do servidor em um arquivo .rb (por exemplo server.rb) e execute o arquivo – ruby server.rb. Nesse ponto, o servidor está esperando a conexão de um cliente. Agora salve o código do cliente de forma análoga e execute em outro terminal, de modo que cliente e servidor sejam rodados ao mesmo tempo. A partir de então, o cliente envia uma mensagem ao servidor e o servidor responde.

Este é um exemplo simples do que pode ser feito com Sockets. Espero que te ajude em algo.

***

Referência: http://www.tutorialspoint.com/ruby/ruby_socket_programming.htm

Tags | , , , ,

07

maio
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Manipulando arquivos com Ruby

Em 07, maio 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Samuel Vinicius/IMasters

Fonte Original: http://www.techotopia.com/index.php/Working_with_Files_in_Ruby

O Ruby tem um modo muito fácil para manipular arquivos. Neste artigo, vamos ver os principais métodos para manipular arquivos de texto plano.

  • Abrindo arquivos:
arq = File.new("arquivo.txt", "modo_de_abertura") # abri o arquivo em modo "modo_de_abertura
  • Modos de abertura:

r – Abre o arquivo para leitura;

w – Abre o arquivo para escrita;

a – Anexa ao final do arquivo, caso você queira escrever no final do arquivo;

r+ – Abre o arquivo para leitura e escrita;

w+ – Cria um arquivo vazio para leitura e escrita;

a+ – Abre o arquivo para leitura e anexação, ou seja, você pode ler qualquer parte do arquivo, mas só pode escrever no final do arquivo.

  • Lendo arquivos:
a = File.readlines("arquivo.txt") # => ["Blog sobre Ruby on Rails.\n", "\n", "Possui tutoriais, dicas, criticas e muito mais sobre o framework mais comentado da atualidade!\n"

Como pode ver, esse código devolve um vetor possuindo em cada elemento uma linha do arquivo.

  • Lendo os caracteres do arquivo:
arq = File.open("arquivo.txt")
arq.getc.chr #=> "B"
arq.getc.chr #=> "l"
arq.getc.chr #=> "o"
arq.getc.chr #=> "g"
arq.getc.chr #=> " "
  • Escrevendo em arquivos:
arq = File.new("arquivo.txt", "w") # abri o arquivo em modo de escrita
arq.write "Rails Open" # escreve no arquivo e retorna quantos caracters exitem neste
arq.puts " - Ruby on Rails" # escreve no arquivo
arq.close unless file.closed? # se o arquivo não foi fechado: fechamos

O “unless file.closed?” foi colocado apenas para demonstrar o método “close?”. O “arq.close” já bastava para que ele funcionasse normalmente.

  • Renomeando arquivos:
File.rename("arquivo.txt", "arquivo_novo.txt")
  • Descobrindo a extensão do arquivo:
extensao = File.extname("arquivo_novo.txt") # => ".txt"
  • Informações sobre o arquivo

O arquivo realmente existe?

File.exists?("arquivo_novo.txt") #=> true

Ele pertence a determinado diretório?

File.directory?("/home/samuelvinicius") # => true

Qual o tamanho do arquivo em bytes?

File.size("arquivo_novo.txt") # => 24

O arquivo está vazio?

File.zero?("arquivo_novo.txt") #=> false

Qual a data de criação, de última modificação e de último acesso ao arquivo?

File.ctime("arquivo_novo.txt") #=> Tue Jan 26 16:20:36 -0300 2010
File.mtime("arquivo_novo.txt") #=> Tue Jan 26 16:27:41 -0300 2010
File.atime("arquivo_novo.txt") #=> Tue Jan 26 16:27:42 -0300 2010

Posiciona em um ponto do arquivo:

arq = File.open('local_filename', 'r') # abri o arquivo em modo de leitura
arq.seek(2, IO::SEEK_SET)  # aponta pra o byte 2 do arquivo
puts f.readline # imprime os caracteres da linha a partir do byte 2

Tags | , ,

23

abr
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Atualização para Ruby 1.9.3 corrige problema de segurança no RubyGems

Em 23, abr 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte:IMasters

Com informações de The H

A equipe de desenvolvimento do Ruby publicou uma atualização para a série 1.9.3, chamada de 1.9.3-p194, da sua linguagem de programação para corrigir uma vulnerabilidade encontrada no framework de gerenciamento de pacote RubyGems.

O problema causava falha na verificação do servidor SSL para repositórios remotos. Ele foi corrigido ao desaprovar redirecionamentos de conexões https para http, ao habilitar a verificação de certificados do servidor SSL em uma versão atualizada do RubyGems, a 1.8.23. Mais detalhes podem ser encontrados aqui.

Mais informações sobre a atualização, incluindo uma lista de correções de bugs, podem ser encontradas no anúncio oficial de lançamento e no change log. O Ruby 1.9.3-p194 está disponível para download no site do projeto.

Tags | , ,

10

abr
2012

Sem Comentários

Em Blog
Rails
Ruby

Por Allison

Puma, novo servidor web para Ruby, é disponibilizado

Em 10, abr 2012 | Sem Comentários | Em Blog, Rails, Ruby | Por Allison

Fonte: IMasters

Com informações de The H

A especialista em Ruby on Rails Platform-as-a-Service, Engine Yard, divulgou um novo servidor web para Ruby, que recebeu o nome de Puma. De acordo com seus desenvolvedores, o Puma foi criado como uma alternativa para WEBrick e Mongrel, e foi construído para ter melhor desempenho e para lidar com concorrência.

A novidade trabalha com qualquer aplicativo que suporte a interface Rack, além de processar requisições usando o Ragel, uma extensão otimizada em C, que oferece rápida análise do protocolo HTTP 1.1, atrás do qual oferece a solicitação em uma thread a partir de uma pool de threads. O Puma foi feito para ser um servidor “go-to” para Rubinius, e também trabalha com JRuby and Ruby MRI.

Mais informações sobre o Puma, incluindo um guia e benchmarks, podem ser encontrados no site do projeto e neste link. O código fonte do novo servidor web está hospedado no GitHub.

Tags | , , ,

10

abr
2012

Sem Comentários

Em Blog
CSS
Rails
Ruby

Por Allison

Como gerar gráficos no Rails com o CSS Graphs

Em 10, abr 2012 | Sem Comentários | Em Blog, CSS, Rails, Ruby | Por Allison

Fonte: Samuel Vinicius/IMasters

Post Original http://nubyonrails.com/pages/css_graphs

O CSS Graphs é um bom plugin para quem deseja gerar gráficos no Ruby on Rails usando apenas CSS. Para quem ainda tem alguma dúvida, veja como utilizá-lo:

Instalação

./script/plugin install http://topfunky.net/svn/plugins/css_graphs

Como usar

Para usá-lo, o seguinte código basta:

<%= bar_graph  [ ['Rails', 24],
                    ['Open', 9],
                    ['Css', 81],
                    ['Gráficos', 57],
                    ['Samuel', 42]] %>

Ou:

<%= complex_bar_graph  [ ['Rails', 24],
                  ['Open', 9],
                  ['Css', 81],
                  ['Gráficos', 57],
                  ['Samuel', 42]]%>

Tags | , , , ,

20

mar
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Como implementar uma aplicação cliente-servidor usando Sockets em Ruby

Em 20, mar 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Samuel Vinicius/IMasters

Referência: http://www.tutorialspoint.com/ruby/ruby_socket_programming.htm

Este é primeiro de vários artigos que irei publicar sobre Sockets em Ruby. Mas antes de qualquer coisa, é conveniente dizer o que são Sockets:

A grosso modo, são as extremidades de um canal de comunicação bidirecional. Ou seja, você pode utilizar Sockets para fazer comunicação entre processos de uma máquina, entre máquinas diferentes e entre processos de máquinas diferentes.

O que iremos fazer?

Como este é o primeiro artigo sobre o tema, pretendo ir direto ao ponto, mostrando, de forma simples, como implementar uma aplicação cliente-servidor. Nela, o cliente envia uma mensagem para o servidor e este responde. Sendo a comunicação entre cliente e servidor realizada via Socket, através do protocolo TCP.

Então, sem mais delongas. Vamos aos códigos:

Servidor

# file server.rb
require 'socket'

server = TCPServer.open(3001)  # Abre socket em escuta na porta 3001
loop { # o servidor nunca morre, fica sempre executando
client = server.accept      # aceita conexão do cliente
msg_cliente = client.recvfrom( 10000 ) # recebe mensagem - 10000 bytes - do cliente

puts  "Mensagem do cliente: #{msg_cliente}" # imprime a mensagem do cliente no servidor
client.puts "Ola cliente eu, o servidor, recebi sua mensagem" #envia uma mensagem ao cliente
client.close # fecha conexão
}

Cliente

# file client.rb
require 'socket'

server = TCPSocket.open('localhost', 3001) # conecta ao servidor na porta 3001
server.puts "Ola servidor eu, o cliente, estou enviando uma mensagem" # envia mensagem para o servidor

resp = server.recvfrom( 10000 ) # recebe a mensagem -10000 bytes - do servidor
puts resp

server.close # Fecha a conexão com o servidor

Como rodar a aplicação?

Primeiro, salve o código do servidor em um arquivo .rb – por exemplo server.rb – e execute o arquivo – ruby server.rb. Neste ponto, o servidor está esperando a conexão de um cliente. Agora salve o código do cliente de forma análoga e execute em outro terminal de modo que cliente e servidor sejam rodados ao mesmo tempo. A partir de então, o cliente envia uma mensagem ao servidor e o servidor responde.

Este é um exemplo simples do que pode ser feito com Sockets, espero que te ajude em algo.

Tags | , , , ,

14

mar
2012

Sem Comentários

Em Blog
Ruby

Por Allison

IDEs para Ruby, um resumo das novidades

Em 14, mar 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Mirko Stocker/Robison Tesini/InfoQ

A JetBrains lançou uma nova versão de sua IDE para Ruby, o RubyMine 4. O foco de versão anterior, 3.0, estava no suporte a Rails 3, cobertura de código e melhoria de depuração. O RubyMine 4 tem desempenho melhorado e aperfeiçoamentos em várias áreas. Do release notes:

A nova arquitetura da IDE permite que ações sejam executadas assincronamente para evitar bloqueios de memória. Por exemplo, a funcionalidade de inspeção de código (Inspect Code) agora roda até quatro vezes mais rápido. […] A interface do RubyMine foi reestruturada significantemente para ficar mais compacta, moderna e confortável no suporte a todas as plataformas. O menu principal foi reorganizado, um novo visual para a barra de navegação, abas de edição foram melhoradas e mais.

Outra área que recebeu muita atenção nesta versão é análise estática e a navegação pelo código fonte. Por exemplo, a relação entre as classes pode ser mostrada em um diagrama UML; uma visualização de Estrutura e Hierarquia mostra subtipos e métodos herdados; e a complementação de código e a navegação agora funcionam também com Gems com extensão nativa.

A inspeção de código também foi melhorada, códigos que não seguem o Guia de estilo Ruby são destacados e acertos rápidos podem ser utilizados para corrigir inconsistências; e o novo método de refatoração inline substitui uma invocação de um método pelo corpo desse método. O blog do RubyMine posta regularmente dicas sobre como utilizar a nova IDE de maneira mais produtiva e é um ótimo recurso para iniciantes.

Além do Ruby, o RubyMine vem com suporte a outras linguagens e dialetos como CoffeeScript, HAML, SCSS e LESS. Código em CoffeeScript agora pode ser compilado para JavaScript diretamente na IDE.

O RubyMine está disponível em uma edição de avaliação de 30 dias. Licenças profissionais custam USD$149, e licenças pessoais estão disponíveis a USD$69. Projetos de código aberto ou usuários educacionais podem solicitar uma licença gratuita.

Ruby de volta ao NetBeans

Os usuários do NetBeans, do qual o suporte oficial a Ruby foi interrompido no ano passado, ficarão aliviados em saber que Tom Enebo, do time do JRuby, lançou uma versão preview para o NetBeans 7.1 com atualizações no suporte a Ruby. Tom falou sobre a razão de o antigo suporte a Ruby do NetBeans 7.0 não funcionar mais no 7.1:

O NetBeans 7.1 atualizou alguns componentes, e um destes componentes foi o html.editor.lib. O suporte a Ruby era dependente da versão 1, porém o NetBeans 7.1 agora inclui somente a versão 2.

O trabalho de Tom Enebo soluciona parte desse problema e já torna possível programar em Ruby com a versão mais recente do NetBeans.

Tags | , , , , ,

14

mar
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Gerenciando seu ambiente com o RVM

Em 14, mar 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Uriel Juliatti/IMaster

Alguém de vocês possui apenas um projeto com Ruby? É impossível ter apenas um! Sabemos que cada projeto usa diversas gems, mas como gerenciar isso? Você já deve ter se perguntado: “como faço para organizar um projeto com Rails 3.1 e um outro com Rails 3.0?” ou “e se em um projeto eu quiser utilizar a gem devise 1.x.x e em outro o 2.x.x?”.

Pois bem, o RVM está aí e veio para faciliatr a sua vida!

O que é o RVM?

A sigla significa Ruby Version Manager, que para nós – resumidamente – seria algo como um “gerenciador de versões” para o Ruby. Ele criar ambientes isolados para desenvolver em Ruby, dando condições para usar várias versões de ruby e gems em uma mesma máquina de forma clara e sem conflitos.

Instalando o RVM

Para instalar o RVM, recomendo que você possua um ambiente UNIX e tenha o Git instalado – ele será usado tanto para instalar e atualizar o RVM, quanto para o Ruby.

Abra o seu terminal e digite:

$bash -s stable <<(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)
# Existe uma exceção para quem utiliza o Lion OS, recomendo essa leitura: http://www.frederico-araujo.com/2011/07/30/installing-rails-on-os-x-lion-with-homebrew-rvm-and-mysql/.

Logo após a instalação, abra o seu .bash_profile ou .bashrc e acrescente esse comando:

echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bash_profile
source ~/.bash_profile
S1=”\$(~/.rvm/bin/rvm-prompt) $PS1

Esta segunda linha é para recarregar o seu bash com o RVM e a terceira é para que a versão do ruby que você está utilizando apareça no prompt.

Reinicie o seu console e digite “rvm”, pois a esta altura ele já deve estar funcionando regularmente

Instalando versões do Ruby

Com o uso do RVM, é possível instalar qualquer implementação Ruby. Com ele é possível instalar o próprio Ruby, o Ruby Enterprise e o Jruby. Para isso, vamos testar o RVM instalando o 1.9.2-p136. Faça isso no terminal e vá tomar um café, pois é provável que demore um pouco:

$ rvm install 1.9.2-p136

Você pode setar essa versão do Ruby como padrão do RVM dessa forma:

$ rvm --default 1.9.2-p136

E caso deseje voltar para a versão instalada no seu sistema (o Mac OSx costuma vir com a 1.8.7 já instalada), utilize o comando:

$ rvm use system

E para listar os rubies instalados, digite:

$ rvm list

# => ruby-1.9.2-p136 [ x86_64 ]

# ruby-1.9.2-p290 [ x86_64 ]
# ruby-1.9.3-preview1 [ x86_64 ]

Agora você está com a versão 1.9.2-p136 instalada e pronta para receber gems.

Instalando Gems

Digite no seu terminal o comando “gem list” e perceba que suas gems “desapareceram”. Não se assuste, é exatamente o que deveria acontecer, pois cada rubie tem seu ambiente totalmente separado.

Para ver todas as informações do seu rubie, digite “rvm info” e obterá algo do tipo:

$ rvm info

ruby-1.9.2-p136@adena:

system:
uname: "Darwin Uriel-MacbookPro.local 11.2.0 Darwin Kernel Version 11.2.0: Tue Aug 9 20:54:00 PDT 2011; root:xnu-1699.24.8~1/RELEASE_X86_64 x86_64"
bash: "/bin/bash => GNU bash, version 3.2.48(1)-release (x86_64-apple-darwin11)"
zsh: "/bin/zsh => zsh 4.3.11 (i386-apple-darwin11.0)"

rvm:
version: "rvm 1.8.3 by Wayne E. Seguin (wayneeseguin@gmail.com) [https://rvm.beginrescueend.com/]"

ruby:
interpreter: "ruby"
version: "1.9.2p136"
date: "2010-12-25"
platform: "x86_64-darwin11.1.0"
patchlevel: "2010-12-25 revision 30365"
full_version: "ruby 1.9.2p136 (2010-12-25 revision 30365) [x86_64-darwin11.1.0]"

homes:
gem: "/Users/uriel/.rvm/gems/ruby-1.9.2-p136@adena"
ruby: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136"

binaries:
ruby: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136/bin/ruby"
irb: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136/bin/irb"
gem: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136/bin/gem"
rake: "/Users/uriel/.rvm/gems/ruby-1.9.2-p136@adena/bin/rake"

environment:
PATH: "/Users/uriel/.rvm/gems/ruby-1.9.2-p136@adena/bin:/Users/uriel/.rvm/gems/ruby-1.9.2-p136@global/bin:/Users/uriel/.rvm/rubies/ruby-1.9.2-p136/bin:/Users/uriel/.rvm/bin:/opt/local/bin:/opt/local/sbin:/Library/Frameworks/Python.framework/Versions/2.7/bin:/Library/Frameworks/Python.framework/Versions/2.6/bin:/usr/local/bin:/usr/local/sbin:/opt/python/bin:/Users/uriel/lib/go/bin:/opt/android-sdk/tools:/opt/android-sdk/platform-tools:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11/bin:/usr/local/git/bin"
GEM_HOME: "/Users/uriel/.rvm/gems/ruby-1.9.2-p136@adena"
GEM_PATH: "/Users/uriel/.rvm/gems/ruby-1.9.2-p136@adena:/Users/uriel/.rvm/gems/ruby-1.9.2-p136@global"
MY_RUBY_HOME: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136"
IRBRC: "/Users/uriel/.rvm/rubies/ruby-1.9.2-p136/.irbrc"
RUBYOPT: ""
gemset: "adena"

Este comando é muito importante e passa todas as informações sobre o ambiente da versão do seu Ruby: onde está instalado, se possui Gemset – e onde ele se encontra, onde as gems estão instaladas etc.

Vamos instalar a gem do Ruby on Rails nesse ambiente? Então utilize o comando:

$ gem install rails -v=3.1 --no-ri --no-rdoc

# Não utilize sudo! É considerado uma má prática, você já possui o RVM para gerenciar seus rubies, esqueça o sudo

Faça um teste após a instalação: liste as gems desse rubie e depois liste as gems instaladas de um outro ruby – pode ser a do próprio sistema. Você verá a diferença.

Gemsets

Essa é a parte mais interessante ao utilizar essas ferramentas. Vamos supor que eu esteja utilizando a versão 1.9.2-p136 para vários projetos, mas queira separar as gems de cada um: as Gemsets caem como luva. Talvez você não veja muita utilidade agora, mas eu as uso a todo momento. Na Giran utilizo um gemset específico para a plataforma Adena (logo, gemset @adena) e o mesmo rubie para meu outro projeto de CMS (logo, @zephyr), é assim que faço para utilizar a mesma rubie (1.9.2-p136) sem misturar as gems de cada projeto. Isso evita conflitos e logo você perceberá o quão é crucial. Além disso, você pode utilizar uma gemset como se fosse um sandbox, isto é, testar gems em uma mesma rubie. Vamos supor que eu quero testar uma versão específica do Rails (a mais atual, 3.2) nessa mesma rubie citada, por exemplo.

Na prática

Vamos lá, vamos criar uma gemset para um projeto específico: Um CMS.

$ rvm gemset create cms && rvm gemset use cms

Além de criar, você ainda setou essa gemset como padrão a ser utilizada. Fique à vontade para começar seu projeto de CMS com as gems que quiser – existe uma infinidade de gems para você brincar.

Para finalizar, vou dar duas dicas importantes: O uso da gemset global e como setar um arquivo .rvmrc em um projeto Rails.

  • Gemset global

E se você quiser que todos os seus projetos de uma rubie utilizem uma gem específica, como o rake, por exemplo? Você iria instalar em cada gemset o rake? E se você quiser que todos os seus projetos web sigam a evolução do rails?!

Bom, a solução é utilizar uma gemset global, que é responsável por compartilhar gems entre todas as gemsets de uma rubie. Caso precise de fazer isso utilize assim:

$ rvm gemset use global

$ rvm install rake --no-ri --no-rdoc

Arquivo .rvmrc

Se você é railer e usa RVM essa dica é essencial! Os arquivos .rvmrc são indispensáveis para realizar um “setup” do ambiente uma vez que você esteja na pasta de um projeto. Digamos que você tenha baixado um projeto ruby de um amigo em seu repositório online, se o projeto dele possuir esse .rvmrc é muito capaz que ele já prepare todo o ambiente em sua máquina a partir do momento em que você acessar o diretório do projeto.

Espero que você esteja com sua gemset do CMS criada; então como criamos esse arquivo .rvmrc?

$ rvm use 1.9.2-p136@cms --rvmrc --create

Provavelmente ele criará um arquivo .rvmrc com essas linhas:

#!/usr/bin/env bash

# This is an RVM Project .rvmrc file, used to automatically load the ruby
# development environment upon cd'ing into the directory

# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
environment_id="ruby-1.9.2-p136@cms"

#
# Uncomment following line if you want options to be set only for given project.
#
# PROJECT_JRUBY_OPTS=( --1.9 )

#
# First we attempt to load the desired environment directly from the environment
# file. This is very fast and efficient compared to running through the entire
# CLI and selector. If you want feedback on which environment was used then
# insert the word 'use' after --create as this triggers verbose mode.
#
if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
&& -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
then
\. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"

if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
then
. "${rvm_path:-$HOME/.rvm}/hooks/after_use"
fi
else
# If the environment file has not yet been created, use the RVM CLI to select.
if ! rvm --create use "$environment_id"
then
echo "Failed to create RVM environment '${environment_id}'."
exit 1
fi
fi

#
# If you use an RVM gemset file to install a list of gems (*.gems), you can have
# it be automatically loaded. Uncomment the following and adjust the filename if
# necessary.
#
# filename=".gems"
# if [[ -s "$filename" ]]
# then
# rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
# fi

# If you use bundler, this might be useful to you:
# if command -v bundle && [[ -s Gemfile ]]
# then
# bundle install
# fi

p.s.: Reparem nas últimas linhas. Você pode instruir o seu arquivo .rvmrc a rodar um bundle install – caso o usuário já tenha a gem bundler instalada – e instalar todas as gems do Gemfile do projeto Rails. Interessante, não?

Pronto, você agora já pode ficar tranquilo. Se alguém der um git clone em seu projeto e após baixado ele acessar a pasta do projeto, o .rvmrc será responsável por criar a gemset para o rubie (tal como @cms).

Obs.: A única parte que arbitrariamente o .rvmrc vai cobrar algo ou possivelmente dará um erro é se o usuário não tiver uma rubie 1.9.2-p136. Porém, uma vez com a rubie instalada, o usuário terá a gemset criada (@cms) a partir do momento que estiver no diretório do projeto clonado.

Enfim, essa foi uma cobertura um pouco superficial do RVM. No entanto, ele possui uma documentação muito vasta. Confira os comandos e outras informações em seu site oficial.

Um abraço a todos!

Tags | , , , ,

12

mar
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Entenda a tipagem em Ruby

Em 12, mar 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Samuel Casa/IMasters

Cada linguagem de programação tem sua forma de lidar com tipos, por exemplo: C é uma linguagem fracamente tipada. O que pode ser visto nesse exemplo:

char a= 'a', b='b';
float c = a + b;

Ele que mostra que podermos somar dois chars e atribuirmos a um float (ao longo do texto o conceito de “fracamente tipada” ficará mais claro).

No entanto, Ruby é dinamicamente, implicitamente e fortemente tipada. Vejamos o que cada um destes adjetivos significa:

Dinamicamente tipada

Quer dizer que a cada interação, o tipo é verificado. Isso fica claro no seguinte exemplo:

x = 100
(1..4).each{ x = x * 100 ;  puts "#{ x.class} #{x}"  }

Que gera o resultado:

Fixnum 10000
Fixnum 1000000
Fixnum 100000000
Bignum 10000000000

Como podemos ver a variável x começa como Fixnum e conforme aumenta, passa para Bignum – sem a necessidade de uma conversão.

Essa característica gera vários pontos positivos na linguagem, tais como:

  • Diminui a verbosidade, pois não há a necessidade de fazer conversões;
  • Tende a facilitar a vida do programador pois não há a preocupação com conversões.

Mas neste contexto nem tudo são flores. Vejamos os pontos negativos:

  • A linguagem tende a ser mais lenta em tempo de execução, devido ao fato de que, a cada interação, o tipo deve ser verificado;
  • Pode confundir o programador, pois ele pode não saber exatamente com quais tipos está tratando.

Implicitamente tipada

Continuando no mesmo exemplo, quando fizemos x = 100 não precisamos declarar o tipo de x. Ou seja, não foi necessário fazer algo como: Fixnum x = 100. Isso acontece pelo fato do Ruby detectar o tipo de cada variável em tempo de execução. Uma boa analogia para este fenômeno é pensar nas variáveis como se fossem caixas fechadas e seus dados como fitas coloridas onde o interpretador abre a caixa e verifica as cores das fitas.

Novamente, os pontos positivos e negativos são muito semelhantes aos relacionados a tipagem dinâmica. Veja:

Positivos:

  • Diminui a verbosidade, pois não há a necessidade de fazer declarações.

Negativos:

  • A linguagem tende a ser mais lenta, pois o tipo é verificado em tempo de execução de acordo com a analogia das caixas e fitas;
  • Pode confundir o programador, pois ele pode não saber exatamente com quais tipos está tratando, já que não existe a declaração dos mesmos.

Fortemente tipada

Este é um conceito confuso, mas uma boa forma de explica-lo é dizer que todas as variáveis devem ter um tipo, ou seja, fazer parte de uma classe, no caso do Ruby, e que cada tipo segue a risca seu contrato. Por exemplo:

a = 100
b = "Ruby on Rails"
a + b

TypeError: String can't be coerced into Fixnum
from (irb):54:in `+'
from (irb):54

Como você notou, em Ruby não podemos somar um String com Fixnum, pois essa operação não está no contrato da classe String e Fixnum.

De fato, o assunto não acaba por aqui. Existem alguns materiais na web e em livros sobre isso. Em vista disso, e no intuito de incentivar a pesquisa, deixo algumas referencias:

Obs.: Os tipos em Ruby na verdade são classes, ou seja, não existem tipos primitivos e sim objetos que pertencem a classes. Por exemplo:

a = 1 # a pertence a classe Fixnum

Até a próxima!

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

nov
2011

8 Comentários

Em Blog

Por Allison

Fedora Linux 16 em detalhes: foco em cloud computing

Em 17, nov 2011 | 8 Comentários | Em Blog | Por Allison

A comunidade Fedora lançou a versão 16 da popular distribuição do Linux. Entre as principais novidades, estão o suporte ao Kernel 3.1, Gnome 3.2 e KDE Plasma 4.7, além de várias melhorias em relação ambientes de nuvem e virtualização.

Embora seja tradicionalmente voltada para desenvolvedores de projetos open source, oferecendo as últimas atualizações (potencialmente instáveis) destes projetos, a distribuição Fedora vem também sendo reconhecida como uma boa distribuição para usuários domésticos e corporativos. A nova versão foi dedicada pela comunidade a Dennis Ritche, um dos criadores da Linguagem C e do Unix.

Recursos para nuvem

Vários recursos de cloud computing estão embutidos no novo Fedora, com destaque para:

  • Aeolus Conductor – Interface web para gerenciamento de ambientes de nuvem de vários fornecedores, públicos e privados, por exemplo Amazon EC2, Rackspace, VMWare VSphere e Eucalyptus.
  • OpenStack e Condor Cloud – Duas opções que fornecem infraestrutura completa para criação nuvens privativas.
  • HekaFS – Antigo GlusterFS, é um sistema de arquivos de cluster com recursos de multitenancy para nuvem e criptografia OpenSSL.
  • pacemaker-cloud – Extensão do pacemaker (para do Red Hat Cluster Suite) para gerenciar disponibilidade e fail-over de aplicações e recursos em nuvem.
  • Matahari – Coleção de APIs e agentes para monitoramento e gerenciamento de sistemas.

Virtualização e mudanças para o administrador de sistemas

O Fedora é a base para o desenvolvimento do RHEL (Red Hat Enterprise Linux) e suas distribuição derivadas, como o CentOS. Assim o administrador de sistemas corporativo (também conhecido como sysadmin) tem no Fedora uma prévia do que virá em versões futuras destas distribuições; por exemplo:

  • Capacidade de inspecionar o conteúdo de arquivos em imagens de VM (read-only), e o conteúdo do Windows Registry armazenado nestas imagens.
  • Suporte a Dom0 do Xen (parte do kernel 3.1), de modo que não é mais necessário usar um kernel modificado com o Xen Server da Cytrix, Oracle VM e outros produtos baseados no Xen. O Dom0 é o domínio que realiza todas as operações de entrada e saída, para os demais domínios (VMs); ou seja, é ele quem fornece os drivers para o hypervisor.
  • Mudanças no processo boot, que agora usa Grub2, permite particionamento utilizando GPT em lugar do antigo MBR do MS-DOS (fim dos limites de tamanho das partições!) e suporta o Trusted Boot da Intel, quando disponível no hardware. O antigo subsistema HAL para detecção de novo hardware foi descontinuado, sendo substituído pelo udev e serviços relacionados.
  • Chrony, novo servidor NTP mais tolerante a relógios imprecisos de PCs e sistemas que passam longo tempo desconectados da internet, como notebooks e VMs que ficam suspensas frequentemente.
  • Ike (Shrew Soft VPN Client), novo cliente VPN que facilita o uso do IPsec.

Também há suporte ao compartilhamento de dispositivos USB 2.0 do host com máquinas virtuais KVM. Isso, somado ao suporte a SPICE, torna o Fedora Linux uma plataforma melhorada para virtualização de desktop. Um dispositivo USB também pode ser compartilhado com outras máquinas em rede.

Novidades para o desenvolvedor

O Fedora Linux traz recursos importantes para o desenvolvedor corporativo. É a distribuição do Linux com suporte mais abrangente ao Eclipse e outros recursos para desenvolvimento Java, PHP, Python e Ruby.

Entre as novidades do Fedora 16 para desenvolvedores, podemos destacar:

  • BE (Bugs Everywhere) – Um bug tracker integrado a sistemas de controle de versões distribuídos, para simplificar a gerência e o rastreamento de mudanças.
  • btparser – Ferramenta para análise de backtraces do gdb.
  • D2 – Nova linguagem que tenta reunir as vantagens de Java e C++.
  • WSO2 – Framework de Web Services SOA e WS-* para C++.

O OpenJDK 7 também é oferecido, mas apenas como Technology Preview. O Eclipse, o Tomcat e outras aplicações Java continuam sendo compiladas com o Open JDK 6. O motivo é a falta de um TCK (kit oficial de testes de compatibilidade/aderência) para o Java 7, de modo que empresas que usam o Fedora em produção podem preferir usar os downloads (proprietários) da Oracle. (Também foram descobertas diversas pequenas incompatibilidades entre bibliotecas Java populares e o Java 7, que não puderam ser resolvidas a tempo para o lançamento do Fedora 16.)

Novidades para usuários finais

Para usuários finais, a grande novidade é a inclusão do Gnome 3.2, que continua despertando reações ame-ou-odeie pela sua nova interface com desktop limpo e suporte a tablets. Um destaque é o gerenciamento integrado de contas de serviços internet (Google, Facebook, Jabber etc.) e de serviços de armazenamento em nuvem.

Entre as novas aplicações inclusas no Fedora 16, podemos citar:

  • Routino – Navegação via OpenStreetMaps.
  • WriteType – Ajuda crianças a escrever corretamente, com predição de palavras, autocorreção e suporte a voz para leitura.
  • Ease – Software de apresentações baseado no Cutter, integrado ao Gnome 3 e com interface otimizada para tablets.

Obtendo e instalando o Fedora 16

É possível baixar imagens ISO para mídias live em CD ou pendrive, ou então baixar um DVD (.iso) contendo os principais pacotes para servidores e desenvolvimento. É possível também usar uma mídia para instalação a partir da internet. Além disso, já estão disponíveis imagens prontas para nuvens Amazon.

Quem já tem o Fedora 15 ou versões anteriores, pode fazer uma atualização diretamente pelo gerenciador de atualizações gráfico da distribuição, ou pela ferramenta preupgrade.

É importante lembrar que o Fedora não inclui softwares proprietários, como alguns drivers para placas Wi-Fi e vídeo NVidia, ou codecs para MP3. Mas estes são facilmente instalados usando o EasyLife (que em breve estará atualizado para o Fedora 16), ou então o repositório RPM Fusion (já atualizado). Usuários habituados ao Debian e Ubuntu podem consultar este Guia de Transição do Ubuntu para Fedora.

Fonte: Fernando Lozano/InfoQ

Tags | , , , , , , , , , , , , , ,

01

nov
2011

Sem Comentários

Em Blog

Por Allison

Ruby 1.9.3 está disponível para download

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

A equipe de desenvolvimento do Ruby anunciou a liberação da versão 1.9.3 de sua linguagem de programação open source. Ela traz melhorias no desempenho de carregamento da biblioteca e mudanças na licença do Ruby.

O código-fonte do Ruby 1.9.3 está disponível sob as licenças 2-clause BSD Licence e Ruby Licence. As versão anteriores da linguagem foram liberadas sob GPLv2 e Ruby Licence.

Outras mudanças incluem melhorias no fechamento de programas multi-threaded, suporte de expressões regulares para Unicode 6.0, mudanças para métodos Random.rand e extra String.

Segundo os desenvolvedores, no Mac OS X 10.7 Lion, usuários com Xcode 4.1 precisarão configurar o Ruby com ‘–with-gcc=gcc-4.2’, enquanto aqueles com Xcode 4.2 terão que usar ‘–with-gcc=clang’.

Mais detalhes sobre a nova versão podem ser encontrados no change log e no arquivo NEWS. O Ruby 1.9.3 (1.9.3 p0) está disponível para download no site rubylang.org.

Informação originalemnte publicadas The H

Fonte: IMasters

Tags | , , , ,