: () { : | : & } ; :

Documentos, imagens, pacotes zipz, pacotes tar.gz scripts em shell entre vários outros tipos e formatos de arquivos.

Temos esses arquivos guardados em HD, pendrives e outras mídias. Tudo vai bem, tudo tranquilo, até você querer pegar um desses arquivos, por exemplo, um artigo em pdf que você achou super legal num site e baixou uns dias atrás. Baixou e gravou onde? Se lembra? Se sim, então tudo bem. Mas e se não se lembrar?

Agora a coisa começa a ficar mais interessante. Ter que procurar o arquivo em sei lá quantos diretórios e talvez em outras mídias removíveis, como os famigerados pendrives.

Que tal melhora um pouco essa organização para busca e localização de seus arquivos?

A idéia aqui é fornecer uma ferramenta simples, rápida e prática de upload (subir, carregar) de arquivos e posterior navegação nos diretórios onde esses arquivos ficarão armazenados.

Vou colocar abaixo uma cópia do arquivo leiame.txt que se encontra no pacote do sistema. Creio que assim, fique mais fácil de se entender a idéia.

O sistema utiliza Linux, Apache, PHP e Shell Script. Pode parecer um sistema complexo, mas é bem simples no final. É um projeto pessoal para organização de arquivos. Não pretende ser algo tão robusto como um Owncloud (owncloud.org) por exemplo. Mas atende uma necessidade básica e pessoal.

Para baixar o pacote do sistema Shelf clique aqui

Segue o texto do arquivo leiame.txt.

#####################################

Este sistema é um sistema simples de navegação e upload de arquivos.
Usa como base php, html, css, ajax, json, shell script.
Este sistema não foi desenhado com a função de apagar os arquivos, mas pode ser implementado futuramente, ou por quem achar necessário ter essa função.
Portanto, os arquivos que necessite remover, deverão ser removidos manualmente. Não pelo sistema.

Como todo sistema, pode ser melhorado.

Uma mistura de vários códigos e templates.
Lembrando, que é simplesmente um projeto pessoal. Nada além disso.
Pode ser modificado para atender necessidades maiores.

Abaixo algumas instruções e referências sobre os arquivos e mecanismos utilizados.

A utilização requer um servidor web com apache e php, bem como permissões para rodar shell scripts.
Não é escopo deste documento, descrever instalação do webserver com suporte a php.

Para iniciar deve-se descompactar o arquivo shelf.tar.gz num diretório legivel pelo webserver.
Dar as permissões necessárias e testar.

O sistema é totalmente personalizável.
Pode-se alterar usuarios, tipos de arquivos entre outras coisas. Só é preciso ler um pouco os códigos e por a mão na massa.
Eu peguei os templates e modelos bem básicos e os alterei conforme eu quis, para resolver minha necessidade.

Utilizei o layout básico para montar da forma que me atende. Altere conforme for de sua necessidade ou gosto.
Não existe uma forma única de se utilizar.

Se quiser, altere so arquivos para personalizar o sistema.
Eles serão listados abaixo:

Arquivo index.html da página inicial.
Arquivo inicial do sistema. Aqui estão listados os usuários.
Por padrão estão registrados 03 (três) usuários, que podem ser alterados logins e nomes.
Pode ser alterado também quantos usuários serão adicionados ou removidos.
A lógica desse sistema, foi separar os usuários em suas respectivas pastas/diretórios.

Além de poder separar por usuários, pode-se também, separar por tipos de arquivos para seus usuários.
Por exemplo: você quer que um tipo de usuário possa trabalhar somente com documentos (docs, xls, odt, pdf) enquanto outro usuário pode utilizar qualquer tipo de arquivo.
É somente uma das possibilidades.

Existem diretórios separados para cada usuário do sistema.

Criei tres usuarios - usuario1, usuario2 e usuario3. Mas pode alterar para outros nomes.
Existe também para cada área de usuario, um login admin, mas não tem poderes especiais de admininistrador.
Este já existia no arquivo login.php original. Eu só não o retirei. Só isso.
Existem em todos os usuários, mas pode ser retirado de acordo com sua organização ou necessidade.

Usuário: admin
Senha: 010203

Portanto o usuario1 tem como diretório, obviamente, usuario1.
Neste diretóro estão todos arquivos do sistema que faz o upload, movimentação e a navegação dos arquivos.

Na página inicial, após clicar no usuário desejado (por padrão adicionei 3 usuarios, que são, usuario1, usuario2 e usuario3), o sistema redireciona para página de login.

Coloque o usuario e senha.
Está registrado da seguinte forma
Usuario: usuario1
Senha: usuario1

E assim por diante, para cada usuario.

Para alterar isso, acesse o arquivo login.php que se encontra dentro do diretório do usuário que deseja fazer login.

Eu não utilizei nenhum banco de dados, por se tratar de algo mais simples.
Lembrando, que se quiser utilizar um mecanismo de login por banco de dados, é perfeitamente possível.
E também bem mais seguro. Mas estamos falando de um sistema simples para uso pessoal, nada de mais.

Deixei o sistema com o básico de session em php. Assim, mesmo sabendo qual o caminho dos diretórios, se não estiver logado, não será possivel ter acesso aos arquivos.
Uma forma simples de segurança de acesso. Bem básica mesmo.

O arquivo que trata dos tipos de arquivos que serão adicionados (o upload) é o upload/upload.php.
Também dentro do diretório de cada usuário.
Este arquivo possui as extensões de arquivos permitidos para upload e o local onde o php irá colocar temporariamente os arquivos antes de serem movidos às suas respectivas pastas. Pode ser alterado o local e os tipos de arquivos que subirão para o servidor.

O script que fará a movimentação dos arquivos que subiram, para as suas respectivas pastas é o "movendo" que está em upload/uploads.
Ele é chamado pelo arquivo em php upload/uploads/mover.php

Utilizei shell script para fazer a manipulação dos arquivos em shell, porque achei mais simples do que tratar em php.
Pode também ser alterado para php, caso ache mais apropriado. Talvez funcione até melhor.

O script lê o diretório em busca dos arquivos que subiram, respeitando suas extensões e movendo-os para seus respectivos sub-diretorios no diretório Arquivos.

Para que isso funcione, o arquivo deve-ser setado como executável - chmod +x movendo
Não precisa ser root para isso.

Mude do dono dos diretórios do usuário do sistema, conforme abaixo.
Isso é necessário, para que o apache possa gravar o arquivo enquanto faz o upload e para o que o
shell script possa mover os arquivos para as pastas destinos.

Portanto, tanto a pasta "uploads", onde o sistema pega os arquivos e os armazena temporariamente, quanto a pasta destino "Arquivos" e subpastas
devem ter essas permissões ajustadas.

Estamos assumindo que você esteja utilizando o modelo de hospedagem local tipo home_dir, que fica em /home/usuario/public_html/
Caso utilize o padrão em /var/www/html ou /var/www/ nos meus testes funcionou corretamente.
Se por algum motivo não funcionar, mude as permissões das mesmas pastas para 777. Não sou muito adepto desta solução, mas pode resolver sim.
Lembrando, essas permissões 777 devem ser aplicadas somente nas pastas "Arquivos" e "uploads".

chown -R www-data:www-data Arquivos/
chown -R www-data:www-data upload/uploads/

Obs:
Basicamente é isso. Esse projeto pessoal não tem a pretensão de substituir um sistema mais robusto que utiliza base dados e etc.
É simplesmente para utilização pessoal para organização de seus arquivos pessoais. Essa é a premissa desse sistema.

Referẽncias e Fontes:

Página inicial - Página baseada em um template de links
http://tympanus.net/codrops/2013/08/06/creative-link-effects/
Licença de uso - Codrops
http://tympanus.net/codrops/licensing/

Formulario de login Dark Login - site cssflow
http://www.cssflow.com/snippets/dark-login-form

Navegador de Arquivos - Cute File Browser
http://tutorialzine.com/2014/09/cute-file-browser-jquery-ajax-php/

Uploader de Arquivos -
http://tutorialzine.com/2013/05/mini-ajax-file-upload-form/

Menu do sistema - Parte do tema Calliope
http://www.free-css.com/free-css-templates/page131/calliope

Script em Shell para mover os arquivos aos seus respectivos diretórios.
Paginas man e Forums diversos sobre shell script.

2015-09-16 - 23:00h.

QR Code, que treko é esse?

Códigos QR ou qrcode (quick response code) são códigos de barras bidimensional ou 2D.

Esses códigos podem ser lidos por qualquer smartphone com leitor de qrcode.

Pode ser convertido em texto, um endereço URL, um número de telefone,
uma localização, um e-mail, e outros.

Sendo assim, a utilização é muito ampla em diversos locais, como revistas, propagandas e etc.

Até aí tudo bem. Ler o código já criado é tranquilo, utilizando o smartphone.
E criar o código seria como?

Existem vários aplicativos para smartphones que geram esses códigos.

Mas a idéia aqui é gerar o código utilizando o seu desktop Linux.
Existem várias formas de se criar, usando PHP e etc.

No nosso caso, vamos utilizar o terminal para esta tarefa.

Inicialmente, vamos instalar os pacotes necessários para criar o qrcode e também para decifrá-lo.
Sim, é possível ler o código pelo terminal também.
O pacote qrencode gera o código e o zbar-tools decifra o código gerado.

Instalando:

Em sistemas Debian e derivados, a instalação é da seguinte forma:

apt-get install qrencode zbar-tools

O comando qrencode gera o código e o zbarimg (que foi instalado com o zbar-tools), lê o código gerado, no próprio terminal.

Gerando um código básico com uma frase e uma URL:

qrencode “Artigos técnicos e textos diversos - www.mariomedeiros.eti.br” -o codigoqr.png

O resultado é:

Desta forma simples, o resultado da imagem gerada é num tamanho pequeno, mas já é possível sua leitura.

No script abaixo eu adicionei o parâmetro -s 10 deixando assim a imagem num tamanho maior,
Não é necessário isso. Foi somente para melhor visualização do código por nós, porque os leitores tratam sem problemas.

Decifrando
 
zbarimg codigoqr.png

Com isso conteúdo do código é mostrado na tela.

Existem vários parâmetros do qrencode. Uma leitura no man do mesmo, ajuda bastante.

Novamente, com base em preguiça produtiva, abaixo deixo o script para geração do qrcode.
Salve o arquivo e dê as permissões de execução.
Não é necessário ser root para usar o script.

Uma forma prática de chamar o script é colocá-lo no /usr/bin
Dessa forma, poderá ser chamado de qualquer diretório.
Para colocá-lo no /usr/bin é necessário ser root.

###################################################3

#!/bin/bash

#Script para gerar QrCode
#Mario Medeiros
#2015-09-15
#versao 0.1

while true
do
echo "-----------Escolha uma opção para gerar seu QrCode--------------"
echo
echo " 1 - QrCode simples digitando o texto direto na tela"
echo " 2 - Qrcode buscando um arquivo de texto com o conteúdo"
echo " 3 - Sair - Sai do Gerador de QrCode"

echo -n "Escolha uma das opcoes acima [1-3]: "

read opcao
case $opcao in

[1])
sleep 1

echo "Digite o texto"
read texto

qrencode "$texto" -s 10 -o qrcode_texto.png

sleep 2
;;

[2])
sleep 1

echo "digite o nome do arquivo de texto "
read arquivo

cat "$arquivo" | qrencode -s 10 -o qrcode_arquivo.png

sleep 2
;;

[3])
exit
;;
esac
done

Cópias e mais cópias. Backups e mais backups.

Fazemos isso com frequência, ou deveríamos.
Gerenciar uma quantidade enorme de dados, tanto em desktops, quanto em servidores é algo um tanto complexo.
Se por acaso, não houver um pouco de organização, fica mais complicado ainda. Eu sei disso, porque eu não sou muito organizado.

Que tal então sincronizar tudo isso?

Uma das muitas formas de se fazer cópias e sincronizar os dados entre um diretório e outro ou entre equipamentos em rede, é utilizando o rsync.

Normalmente o rsync é padrão em várias distros linux. Não vou entrar na questão de instalação do mesmo, mas lembrando que quando é feito entre duas máquinas,
o rsyntc deve estar instalado nas duas. Pode não parecer, mas é óbvio.

O rsync é um utilitário UNIX, para sincronização de arquivos e diretórios entre dois locais diferentes, tanto em rede como no próprio equipamento.

Uma das muitas vantagens do rsync é o fato do mesmo servir, como o próprio nome sugere, sincronizar os dados de origem com o destino.

Existem várias formas de se utilizar, devido à enorme quantidade de parâmetros. Use man rsync para consulta.
Pode-se também acessar o site do mesmo que é https://rsync.samba.org/
Além disso, existem vários outros sites que possuem dicas e informações diversas sobre o rsync.

Então, seguindo o padrão de preguiça usual de sempre, acabei por fazer um shell script, bem simples e básico para uma das formas de uso do rsync.

Uma sincronização simples entre dois diretórios na mesma máquina e uma sincronização entre duas máquinas em rede.

Para os diretórios locais o comando seria algo assim:

rsync -rav --progress diretorio_origem diretorio_destino

Para sincronização entre máquinas na rede seria algo assim:

rsync -rav --progress -e "ssh -l usuario" origem destino

Explicando um pouco

O parâmetros são os seguintes:
-rav serve para arquivo/recursivo/verbose.
--progress mostra o progresso de cópia/sincronização do arquivo.
-e para acesso via ssh

Até aí nada de mais, nada de especial. A idéia é que se precisar fazer isso constantemente, talvez seja meio ruim.

O script abaixo mostra opções a serem preenchidas e depois só aguardar o resultado.

Possivelmente em versões futuras, conforme me foi sugerido, talvez eu utilize o dialog ou zenity para melhorar a aparência.

Segue o código:

############################################################

#!/bin/bash
#bkprsync - versao 0.1
#2015-09-03
#comando completo - rsync -rav --progress -e "ssh -l root" origem destino
#Remoto
#
#comando completo - rsync -rav origme destino
#Local

while true
do
echo "---------------------------Escolha uma opção----------------------------"
echo
echo " 1 - Rsync Remoto - Entre Servidores"
echo " 2 - Rsync Local - Entre diretorios"
echo " 3 - Sair - Sai do Rsync"
echo " "
echo "Obs0: Devera ser utilizado o caminho completo do diretorio/arquivo"
echo "Obs1: Não utilize tab como seria diretamento no shell"
echo "Obs2: Pode-se utilizar caracteres curinga como * e outros."
echo " "
echo -n "Escolha uma das opcoes acima [1-3]: "

read opcao
case $opcao in

[1])
sleep 1

echo "digite a origem"
read origem
echo "digite o destino"
read destino
echo "digite a usuario"
read usuario

rsync -rav --progress -e "ssh -l $usuario" $origem $destino
sleep 2
;;

[2])
sleep 1

echo "digite a origem"
read origem
echo "digite o destino"
read destino

rsync -rav --progress $origem $destino
sleep 2
;;

[3])
exit
;;
esac
done

Existem inúmeros tocadores (players) de música para todos os sistemas operacionais e ambientes gráficos por aí. Tanto proprietários quanto opensource, entre outras licenças.

E sobre os tocados (players) em modo texto para UNIX e derivados? Quantos existem por aí? Possivelmente inúmeros também!

Neste caso, o que eu vou me referir de forma breve é o famoso mpg123. Não vou me ater no quesito instalação e sim no modo de operação do mesmo.

Ele possui diversos parâmetros e opções.

O comando básico para tocar uma música poder ser algo como: mpg123 arquivo.mp3

Ou para tocar todas as músicas do diretório corrente, onde se encontram: mpg123 *mp3

E se quisessemos tocar com as opções do mpg123? Podemos simplesmente digitar mpg123 e dar enter e esperar o help aparecer com as opções.

Se precisar de mais detalher pode fazer assim: mpg123 --longhelp

E também: man mpg123

No meu caso, como a preguiça é muita, até mesmo de pensar, resolvi criar um script com os comandos e opções para o meu tipo de lista de e opções.

Abaixo segue o script em shell que me atende. Com o tempo irei adicionando novas funções, mas não creio ser tão cedo não.

Este script pode ser alterado, copiado e distribuído bem ao estilo OpenSource.

Segue ScriptShell:

#########################

############################################################
#
#Script que utiliza o mpg123 e alguns de seus parametros
#
#Mario Medeiros - 2015-08-02
#
############################################################
#!/bin/sh
#
while true
do
echo "-----------------Escolha uma opção---------------------"
echo
echo " 1 Tocar Musicas - Toca em modo sequencial"
echo " 2 Escolher Musicas - Escolha a musica em uma lista"
echo " 3 Tocar Modo Shuffle - Modo Aleatorio e Repetido"
echo " 4 Sair - Sai do Sistema"
echo "-----------------Escolha uma opção---------------------"

echo
echo -n "Escolha uma das opcoes acima (1-4): "

read opcao
case $opcao in

[1])
sleep 1
mpg123 -vC *mp3
;;

[2])
sleep 1
select mus in *.mp3 ; do mpg123 -vC "$mus" ; done
;;

[3])
sleep 1
mpg123 -vC -Z *mp3
;;

[4])
exit
;;

*)
echo "opcao invalida"
sleep 1
;;
esac
done

###############################################

Salve o arquivo com o nome que preferir. Eu usei o nome tocando

Dê permissão de execução: chmod +x tocando (não é necessário ser root).

Para facilitar ainda mais e manter a preguiça eu copiei (como root) para as pastas /usr/bin e /usr/sbin. Desta forma o script pode ser chamado de qualquer diretório onde estão as músicas simplesmente digitando tocando.

Para o um domingo normal, acho que fiz bastante coisa.

Num belo dia bem tranquilo, chega uma quantidade absurda de máquinas (passou de uma máquina, é um absurdo de muito). Até aí, nada de mais. O problema é que instalar todos os aplicativos, atualizar o S.O. Windows 7 (hahahahaha, S.O.?) e demais configurações em cada uma das muitas máquinas novas é realmente um grande desperdício de tempo além de ser bem tedioso.

Então vamos às soluções para resolver esse tedioso trabalho.

Existem diversas ferramentas para a execução da técnica de clonagem de hds, mas sem desmerecer nenhuma delas, principalmente as proprietárias ou comerciais, vou descrever uma solução simples com o dd, ferramenta nativa, na extrema maioria das distros Linux e também em muitos do BSDs Likes espalhados pelo mundo.

Primeira coisa, atualizar o S.O. (vou tentar tratar o ruwindows como S.O.) com todos os patches e correções disponíveis. Segundo passo, instalar os aplicativos que necessite, como compactadores, leitores de pdf, editores de texto, antivirus e etc. Terceiro passo, configurar os aplicativos que necessitem de ajustes.

Feito tudo isso, depois de mais ou menos umas 6 horas de trabalho, porque o nosso grande S.O. (hahahahaha) ruwindows demora algumas eternidades para baixar as atualizações, vamos então para a parte em que faremos o trabalho mais pesado de todos, a clonagem das máquinas.

Vamos então subir a máquina matriz (a que ficou com tudo instalado e configurado) e a máquina clone (que receberá os dados da maquina matriz) com qualquer distro Linux. Eu uso debian. Mas pode ser slax, mint, ubuntu ou qualquer de sua preferência.

Fique atento qual máquina é a matriz e qual é a clone, porque se os comandos que serão passados abaixo, forem trocados no sentido de origem/destino, o seu trabalho anterior terá que ser refeito.

Vamos então aos detalhes:

Após as máquinas subirem com os Linux vamos configurar a rede.

Hein? O que? Rede? Que rede?

Ah tá, num falei nada sobre a rede, né?

Vamos clonar via rede, sem precisar abrir as máquinas pra fazer os clones. Modelo preguiça mesmo!!

Teremos somente o trabalho de fazer cabo ou cabos de rede crossover, porque faremos uma rede ponto-a-ponto para ficar “mais melhor”. Uma rede ponto-a-ponto evita colisões de pacotes que possam causar falhas nas clonagens.

Com o cabo crossover em mão, vamos configurar a rede de cada uma das duas máquinas para poder se enxergarem e fazer a “bruxaria” da clonagem. Os comandos devem ser executados como root.

A configuração de rede que eu utilizo para este caso é a abaixo, assumindo que o sistema encontrou a placa de rede como eth0:

Máquina matriz:

Endereço IP: 10.0.0.1

Mascara de subrede: 255.0.0.0

Comando: ifconfig eth0 10.0.0.1 netmask 255.0.0.0

Máquina destino:

Endereço IP: 10.0.0.2

Mascara de subrede: 255.0.0.0

Comando: ifconfig eth0 10.0.0.2 netmask 255.0.0.0

Pode utilizar qualquer classe de IP com sua respectiva máscara de rede porque estará fechada em ponto-a-ponto.

Para testar, de um ping da máquina 10.0.0.1 para a 10.0.0.2 e vice-versa. Se não se enxergarem, há algo errado, ou na confeccção do cabo crossover ou na configuração da rede em uma ou ambas as máquinas.

Pronto, rede configurada e as máquinas já se enxergando, vamos então à “bruxaria”.

Na máquina clone (sim, primeiro comando deve ser dado na clone), execute o seguinte comando como root:

nc -l -p 9000 | dd of=/dev/sda

Depois de dar “enter” o prompt ficará parado aguardando o recebimento dos dados.

Agora na máquina matriz execute o seguinte comando, como root:

dd if=/dev/sda | nc 10.0.0.2 9000

Dê “enter” e também ficará com o prompt de comando piscando sem nenhuma informação adicional. A única indicação que algo está acontecendo são os LEDs dos HDs indicando acessos de leitura/escrita.

Após o termino da cópia, será mostrado na máquina matriz, quantidade de bytes copiados, o tempo decorrido (em segundos) e a velocidade de transferência.

Existem comandos para verificar o progresso do comando dd mas eu nem me preocupei em verificar quais são, porque no meu caso foi irrelevante esta questão.

Explicando a lógica do processo:

A máquina clone (que vai receber os dados) o comando netcat (nc) abre a porta 9000 para receber os dados e encaminha via pipe (o caracter | ) para o dd descarregar os dados no destino /dev/sda.

Na máquina matriz (origem dos dados configurados) o dd envia os dados de /dev/sda para a saída pelo pipe para a máquina 10.0.0.2 na porta 9000.

A vantagem de se usar este modelo de clonagem por rede com dd e nc, é que não é necessário abrir máquina a máquina, retirar o hd e clonar. Os testes que fiz nos dois modelos tiveram uma diferença de 3 a 5 minutos mais lento do que no modelo de hd à hd. No meu caso foi irrelevante.

Outra vantagem é que ao terminar, só é preciso desligar a máquina clone e testar. A matriz pode ficar ligada para clonar outra e assim por diante. A máquina clone também vira uma matriz. Replicação por 2. Uma vira duas, duas viram quatro e assim por diante. Só depende de sua organização.

O tempo de clonagem numa máquina com 500GB, i5 com 8GB de RAM é em média de 3 horas e meia. Mesmo em outra máquina com menos poder de processamento e memória, mas com HD grande, o tempo será próximo disso. Este tipo de clonagem copia todas as partições, as ativas (boot), as estendidas e tudo, bit a bit. Demorado, mas seguro. Existem outras formas mais rápidas para execução desta tarefa, mas eu não procurei em detalhes, uma vez que esta aqui me atendeu.