Hibernação no Mac OS X

E já que falei de modo sleep, como hiberna no Mac OS X?

Essa pergunta gerou muita confusão entre os “entendidos” de Mac OS. Alguns me diziam que colocavam no modo sleep ou simplesmente fechavam a tampa do notebook (que forçava o modo sleep).
Cheguei a fazer esse procedimento duas vezes, porém o fato de transportar um notebook com HD e tudo mais ainda ligados me incomoda, já que isso pode gerar um problema de hardware. Então resolvi pesquisar se realmente o modo sleep faria o computador economizar a energia totalmente e se os discos ficavam desligados.

Na verdade eu nem precisava pesquisar. Deixei o notebook em modo sleep por mais de 14 horas e quando abri a tampa, a bateria estava consumida pela metade…

Fui procurar como fazer para salvar a sessão em disco e poder desligar o notebook totalmente (modo de hibernação no caso do windows/ubuntu) para evitar problemas.

Basicamente existem dois modos:

1 – Baixar um widget no site http://deepsleep.free.fr/. Ele vai instalar um link no dashboard. Sempre que você precisar desligar o Mac OS mas precisa manter sua sessão salva como ficou, basta clicar nesse ícone. Lembrando que a hibernação é um processo mais demorado, já que o sistema precisa salvar tudo que ficou aberto e depois precisa abrir tudo do jeito que estava, mas sinceramente vale muito mais a pena do que esperar um problema no disco.

2 – Verficar o modo hibernate atual do sistema:
pmset -g | grep hibernatemode

Por default, retornará hibernatemode 3

Seguem os modos disponíveis:
# 0 – A RAM fica ligada o tempo todo, não tem o modo safe sleep e a única vantagem é que o retorno é rápido
# 1 – Hibernação onde o conteúdo da RAM é gravado no disco do sistema, totalmente desligado enquanto estiver “dormindo”, wake up é mais lento.
# 3 – É o modo padrão nas máquinas desde 2005. A RAM fica ligada enquanto estiver “dormindo”, mas o conteúdo RAM também é gravado no disco antes de dormir. Só entra em modo de hibernação total quando acaba a energia da bateria.
# 5 – É igual ao modo 1, mas é para aqueles que utilizam memória virtual de segurança (em Preferências do Sistema -> Segurança).
# 7 – Igual ao modo 3, mas é para aqueles que usam memória virtual segura.

Para alterar o modo:
Exemplo: sudo pmset -a hibernatemode 0 (ou 1, 3, 5, 7)

Eu basicamente preferi simplesmente instalar o widget da primeira opção. =)

Memory leak em Java: O que é, como se faz e como evitar

Ao contrário do que muitas pessoas pensam, uma aplicação escrita em Java pode sim apresentar problemas de vazamento de memória, termo comumente conhecido por memory leak. Infelizmente, um grande número de programadores Java acha que memory leak é coisa de C/C++ e que o garbage collector do Java resolve esse problema completamente. Neste artigo pretendo mostrar que o garbage collector, apesar de ser funcionar muito bem, não é capaz de fazer mágica.

Memory leak significa exatamente o que o seu nome diz: vazamento de memória.
Ele pode ser de dois tipos:
1) Blocos de memória: estão alocados e disponíveis para serem usados pela aplicação, mas não são acessíveis porque a aplicação não tem nenhum ponteiro* apontando para essa área de memória. Logo, estes blocos de memória não podem nem ser usados nem pela aplicação e nem por outros processos.
2) Blocos de memória: possuem dados que poderiam ser liberados por serem inacessíveis e que, por “esquecimento”, ainda são referenciados no código mesmo sem estarem sendo usados, não podendo ser liberados.

A situação 1 é muito comum em C/C++. Aloca-se uma quantidade de memória usando a função malloc*, por exemplo, e na seqüência o programador faz com que o ponteiro para essa área de memória passe a apontar para outro local, perdendo a referência inicial. Em Java este tipo de memory leak não ocorre, pois o garbage collector é capaz de detectar blocos de memória alocados e não referenciados e liberá-los para uso posterior.

É na situação 2 que mora o problema. Mas antes de explicar como esse problema pode ocorrer e como evitá-lo, vamos entender um pouco mais como funciona o garbage collector do Java.
1. Um ponteiro é uma variável que aponta para um endereço de memória. É um termo bastante comum em C/C++ e engana-se quem acha que Java não possui ponteiros. Quando um objeto é criado usando new, a variável que recebe o objeto é, na verdade, um ponteiro que aponta para um endereço de memória que contém o objeto.
2. A função malloc() faz parte da API do C. Sua função é alocar a quantidade de memória desejada (fornecida como parâmetro). O retorno desta função é um ponteiro para a área de memória recém criada.

O Papel do garbage collector
Uma das grandes vantagens do Java sobre linguagens de programação de mais baixo nível é a presença do garbage collector (coletor de lixo). A função do dele é vasculhar a memória atrás de blocos alocados que não tenham mais como ser referenciados pela aplicação. Quando o garbage collector se depara com uma situação desse tipo, ele desaloca a memória, tornando-a disponível para ser usada novamente pela aplicação.

Ver o garbage collector funcionando no Java é muito fácil. Observe este código:
public static void main(String[] args) throws Exception {
int[] array = null;
while(true) {
array = new int[1000];
System.out.println(“Bytes livres: “+ Runtime.getRuntime().freeMemory());
Thread.sleep(200);
}
}

Este código fica executando em um loop infinito. A cada iteração do loop, um array de 1000 posições de inteiros é criado. Cada vez que o loop é executado, é mostrada a quantidade de bytes livres. Num primeiro momento você pode pensar: “esta aplicação vai acabar com a memória da JVM?”. Mas na verdade não é isso que acontece. Ao executar o programa, em determinado momento você vai observar a seguinte saída:

Bytes livres: 1530520
Bytes livres: 1530520
Bytes livres: 1530520
Bytes livres: 1526504
Bytes livres: 1522488
Bytes livres: 1518472
Bytes livres: 1514456
Bytes livres: 1510440
Bytes livres: 1912792
Bytes livres: 1912792
Bytes livres: 1908776
Bytes livres: 1904760
Bytes livres: 1900744
Bytes livres: 1896728
Bytes livres: 1892712

A memória estava acabando e, repentinamente, ela aumentou. A explicação disso é simples. Quando o loop é executado, é criado o array. Na próxima iteração do loop, o array criado na iteração anterior não é referenciado por mais ninguém (perceba que a variável array deixou de apontar para o array antigo e passou a apontar para o novo array, fazendo com que o array antigo ficasse inacessível). Em determinado momento, a JVM percebe a queda da memória disponível e coloca o garbage collector em execução. O garbage collector então descobre que essa memória que foi sendo alocada no decorrer dos loops está inacessível e a libera. É neste momento que podemos perceber que a memória disponível aumenta.

Depois de ver este código rodando, você deve estar se perguntando: “como eu sei quando o garbage collector vai ser executado?”. Não é possível saber. O controle da execução do garbage collector é da JVM. Quando a JVM decidir que é hora de executá-lo, ele será executado. Note que executar o garbage collector toda hora não seria recomendável, já que ele ocupa recursos computacionais.

Outro ponto importante a respeito do garbage collector é que, como ele é controlado pela JVM, não é possível forçar a sua execução via programação. O máximo que pode ser feito é a chamada do método System.gc() (ou Runtime.getRuntime().gc()). Este método notifica a JVM que a aplicação gostaria que o garbage collector fosse executado, mas não garante que ele realmente será executado no momento desejado.

O método finalize
A classe Object do Java possui um método chamado finalize(), que pode ser sobrescrito pelas classes que herdam de Object (isto é, qualquer classe). Quando o garbage collector decide que determinado objeto será destruído por não ser mais referenciado, ele chama o método finalize() no objeto logo antes de destruí-lo.

Apesar do método finalize() ser uma chance que o programador tem para liberar recursos associados ao objeto no momento em que ele será destruído, sobrescrever o finalize() não é recomendado em nenhuma situação. O motivo é simples: como não existe garantia que o objeto será destruído, também não existe garantia que o finalize() será executado. A própria Sun não recomenda sobrescrever o método finalize(). A liberação de recursos pode ser feita de outras formas, como utilização de blocos try/catch/finally e/ou criação de métodos específicos para este fim (método close(), por exemplo).

Para mais informações sobre este tópico, consulte: http://java.sun.com/developer/TechTips/2000/tt0124.html.

Causando um memory leak em Java
Após o entendimento do que é um memory leak e como funciona o garbage collector do Java, vamos agora mostrar como causar um memory leak em Java e o que fazer para evitá-lo. Primeiramente, gostaria de reforçar que memory leaks são difíceis de descobrir (às vezes é preciso recorrer a ferramentas externas) e sempre são causados por erro de programação. Normalmente os programadores não se preocupam muito com eles, até o momento em que começam a consumir uma quantidade excessiva de memória ou até derrubar a JVM (quando a memória acaba, a JVM lança um java.lang.OutOfMemoryError e termina).

Comentei na seção 3 que o garbage collector é capaz de detectar objetos não-referenciados e destruí-los, liberando a memória. Para criar um memory leak basta manter a referência a um ou mais objetos no código, mesmo sem utilizá-la depois. Dessa forma o garbage collector nunca poderá destruir os objetos, e eles continuarão existindo na memória mesmo não sendo mais acessíveis. Observe este exemplo simples de implementação de uma pilha:

public class Pilha {
private List pilha = new ArrayList();
int count = 0;
public void push(Object obj) {
pilha.add(count++, obj);
}
public Object pop() {
if(count == 0) {
return null;
}
return pilha.get(–count);
}
}

Cada vez que um elemento é colocado ou removido da pilha, um contador controla a posição do último elemento. Este é um caso visível de memory leak. A pilha tem referências cadastradas para todos os objetos contidos nela. No entanto, por mais que os objetos sejam todos removidos da pilha, a pilha continuará referenciando os objetos removidos, o que impossibilitará o gargabe collector de recuperar esta memória.

Para resolver a situação nesse caso, basta eliminar a referência ao objeto quando ele for removido da pilha:

public class Pilha {
private List pilha = new ArrayList();
int count = 0;
public void push(Object obj) {
pilha.add(count++, obj);
}
public Object pop() {
if(count == 0) {
return null;
}
Object obj = pilha.get(–count);
pilha.set(count, null);
return obj;
}
}

Atribuir a referência do objeto para null fará com que a pilha não mais referencie o objeto, possibilitando ao garbage collector a destruição do mesmo.

Este exemplo tem por objetivo mostrar como memory leak em Java é possível. É difícil alguém implementar uma pilha desta forma (ainda mais que Java já possui uma classe Stack para esta finalidade). De qualquer forma, imagine uma situação semelhante a essa onde milhares ou até milhões de objetos fiquem inacessíveis e ainda assim referenciados. Numa aplicação rodando sem parar num servidor de aplicação, por exemplo, isso pode acarretar o término da JVM por falta de memória após alguns dias de memory leaks acumulados. Numa situação como essa, encontrar o erro pode ser uma tarefa extremamente complicada e trabalhosa.
Recomendações para evitar memory leaks

Acredite: seguir algumas recomendações para evitar os memory leaks é muito mais fácil do que detectá-los após o código ter sido finalizado. Como o garbage collector facilita bastante o trabalho do programador, basta prestar atenção em alguns pontos principais que são causas comuns de memory leaks:
* Cuidado com coleções de objetos (arrays, listas, maps, vectors, etc.). Às vezes elas podem guardar referências de objetos que não são mais necessários.
* Ainda relacionado às coleções de objetos, se as mesmas forem static ou durarem todo o tempo de vida da aplicação, o cuidado deve ser redobrado.
* Ao programar situações onde seja necessário registrar objetos como event listeners, tome o cuidado de remover os registros desses objetos caso não sejam mais necessários. Resumindo: elimine todas as referências a objetos desnecessários. Fazendo isso, o garbage collector terá condições de fazer o seu trabalho completamente e você estará livre dos memory leaks em suas aplicações.

Este artigo procurou demonstrar que memory leaks existem em Java, ao contrário do que muitas pessoas pensam. Foi mostrado como criar uma situação de memory leak e como cuidar para que situações desse tipo sejam evitadas, a fim de não prejudicarem as aplicações.

==========
Fonte:

Dicas para aumentar a segurança do WordPress

O WordPress é atualmente a maior referência em gerenciador de conteúdo livre.
A facilidade de uso permite a criação de um blog em minutos.

Como 99% dos blogueiros estão mais preocupados em disponibilizar conteúdo e monitorar as estatísticas do seu blog, eles acabam esquecendo que existem visitantes sedentos para encontrar vulnerabilidades que permitem ataques como SQL Injection, Session Hijacking, entre outros.

Para ajudar nessa administração, segue uma coletânea de ações e ferramentas que ajudarão na tarefa de manter seu blog disponível, integro e confiável.

– Mantenha o WordPress e os Plugins atualizados: Plugin WordPress Automatic Upgrade;
– Faça backups diários: Plugin WP-DBManager;
– Altere sua senha constantemente e faça uso de senhas fortes;
– Renomeie o usuário admin: Plugin Admin Renamer Extended;
– Elimine plugins desnecessários;
– Conecte usando SFTP ou SSH ao invés do FTP;
– Renomeie as tabelas do WordPress DB: Plugin WP Security Scan;
– Oculte o contéudo do diretório Plugins: Faça isso criando um arquivo index.html em branco neste diretório;
– Evite que ferramentas de buscas indexem os diretórios do WP: Faça isso criando um arquivo robots.txt adicionando a linha “Disallow: /wp-*” dentro deste arquivo;
– Proteja a autenticação no WP: Plugins Login Lockdown e Chap Secure Login;
– Bloqueie a navegação nos diretórios: Edite o arquivo .htaccess adicionando a linha “Options All -Indexes”;
– Oculte a versão do WP: Plugin Secure WordPress;
– Faça um scanning de vulnerabilidades no WP: Plugins WP-Scanner e Exploit Scanner

OBS: Muito cuidado na utilização de alguns plugins. A instalação de muitos plugins podem degradar o desempenho do seu blog.

Fontes:
Alexos

20+ Ways to Harden and Secure Your WordPress Blog

Hardening WordPress

20 WordPress Security Plug-ins And Tips To keep Hackers Away

WordPress Security FAQ

WordPress Security Links

Guia de comandos do VI

O editor VI é uma mão na roda para quem trabalha com Unix/Linux.
Abaixo alguns comandos muito úteis:

Executando o vi:
$ vi arquivo

Uma vez carregado, poderão ser executados os seguintes comandos dentro do vi.

Comandos básicos:
* :wq – Salva o arquivo e sai do editor
* :w nome_do_arquivo – Salva o arquivo corrente com o nome especificado
* :w! nome_do_arquivo – Salva o arquivo corrente no arquivo especificado
* :q – Sai do editor
* :q! – Sai do editor sem salvar as alterações realizadas

Comandos de inserção:
* i – Insere texto antes do cursor
* a – Insere texto depois do cursor
* r – Insere texto no início da linha onde se encontra o cursor
* A – Insere texto no final da linha onde se encontra o cursor
* o – Adiciona linha abaixo da linha atual
* O – Adiciona linha acima da linha atual

Comandos de movimentação:
* Ctrl+f – Move o cursor para a próxima tela
* Ctrl+b – Move o cursor para a tela anterior
* H – Move o cursor para a primeira linha da tela
* M – Move o cursor para o meio da tela
* L – Move o cursor para a última linha da tela
* h – Move o cursor um caractere a esquerda
* j – Move o cursor para a próxima linha
* k – Move o cursor para linha anterior
* l – Move o cursor um caractere a direita
* w – Move o cursor para o início da próxima palavra (Ignora a pontuação)
* W – Move o cursor para o início da próxima palavra (Não ignora a pontuação)
* b – Move o cursor para o início da palavra anterior (Ignora a pontuação)
* B – Move o cursor para o início da palavra anterior (Não ignora a pontuação)
* 0 – Move o cursor para o início da linha atual
* ^ – Move o cursor para o primeiro caractere não branco da linha atual
* $ – Move o cursor para o final da linha atual
* nG – Move o cursor para a linha n
* G – Move o cursor para a última linha do arquivo

Comandos de busca:
* /palavra – Busca pela palavra ou caractere em todo o texto
* ?palavra – Move o cursor para a ocorrência anterior da palavra
* n – Repete o último comando / ou ?
* N – Repete o último comando / ou ? , na direção reversa
* Ctrl+g – Mostra o nome do arquivo, o número da linha corrente e o total de linhas

Comandos de substituição e deleção:
* x – Deleta o caractere que esta sob o cursor
* dw – Deleta a palavra, da posição atual do cursor ate o final
* dd – Deleta a linha atual
* D – Deleta a linha a partir da posição atual do cursor ate o final
* rx – Substitui o caractere sob o cursor pelo especificado em x(é opcional indicar o caractere)
* Rx – Substitui a palavra sob o cursor pela palavra indicada em x
* u – Desfaz a última modificação
* U – Desfaz todas as modificações feitas na linha atual
* J – Une a linha corrente a próxima
* s:/Linux/Unix – Substitui a primeira ocorrência de “Linux” por “Unix”
* s:/Linux/Unix/g – Substitui a ocorrência de “Linux” por “Unix” em todo arquivo

==========
Fonte:Viva o Linux

Os metacaracteres das expressões regulares

Meta Nome Descrição
. Ponto Curinga de um caractere
[] Lista Casa qualquer um dos caracteres listados
[^] Lista negada Casa qualquer caractere, exceto os listados
? Opcional A entidade anterior pode aparecer ou não (opcional)
* Asterisco A entidade anterior pode aparecer em qualquer quantidade
+ Mais A entidade anterior deve aparecer no mínimo uma vez
{,} Chaves A entidade anterior deve aparecer na quantidade indicada
^ Circunflexo Casa o começo da linha
$ Cifrão Casa o fim da linha
b Borda Limita uma palavra (letras, números e sublinhado)
Escape Escapa um meta, tirando seu poder
| Ou Indica alternativas (usar com o grupo)
() Grupo Agrupa partes da expressão, é quantificável e multinível
1 Retrovisor Recupera o conteúdo do grupo 1
2 Retrovisor Recupera o conteúdo do grupo 2 (segue até o 9)
.* Curinga Casa qualquer coisa, é o tudo e o nada
?? Opcional NG Idem ao opcional comum, mas casa o mínimo possível
*? Asterisco NG Idem ao asterisco comum, mas casa o mínimo possível
+? Mais NG Idem ao mais comum, mas casa o mínimo possível
{}? Chaves NG Idem às chaves comuns, mas casa o mínimo possível

Metacaracteres que são diferentes nos aplicativos

Programa Opc Mais Chaves Borda Ou Grupo
awk ? + | ()
ed ? + {,} b | ()
egrep ? + {,} b | ()
emacs ? + b | ()
expect ? + | ()
find ? + b | ()
gawk ? + {,} <> | ()
grep ? + {,} b | ()
mawk ? + | ()
perl ? + {,} b | ()
php ? + {,} b | ()
python ? + {,} b | ()
sed ? + {,} <> | ()
vim = + {,} <> | ()

==========
Fonte: Aurelio.Net