Script para backup de DataBases SQLServer – parte 01

ProblemUm problema comum no mundo de banco de dados são os backups. Realizar diversos backups de diversas bases manualmente é tarefa de estagiáriocorno. As vezes as coisas podem parecer mais complicadas do que realmente são. Por isso esse tutorial mostrará como fazer o backup de suas bases de seu banco de forma simples e rápida. Usar o SQLManager e os planos de manutenção são uma boa. Mas as normalmente o bom e velho script tem um comportamento mais simples e mais fácil de se manobrar.
Como podemos gerar backups usando o T-SQL? Simples:
BACKUP DATABASE DBNAME TO DISK = "c:\backup.bak"
Esse seria o mais simples de todos, fazendo de um só banco, vc colocando o nome do seu banco. Mas e se você tiver diversos bancos e não está com a menor paciência pra escrever várias linhas iguais a essa para fazer o backup de cada banco? Ou ainda e se você possuir diversos servidores, com cada servidor com diversos bancos que precisam ter um backup e não terá tempo para escrever nome por nome de banco?
Bem, agora sim as coisas poderiam ficar complicada, mas a verdade é que essa complicação não existe. Veja:
DECLARE @name VARCHAR(50) -- nome do banco de dados
DECLARE @path VARCHAR(256) -- path para o arquivo de backup
DECLARE @fileName VARCHAR(256) -- nome do arquivo de backup
DECLARE @fileDate VARCHAR(20) -- usado para o nome do arquivo

SET @path = 'C:\Backup\' --diretório onde tudo será salvo

SELECT @fileDate = CONVERT(VARCHAR(20),GETDATE(),112)

DECLARE db_cursor CURSOR FOR
SELECT name
FROM master.dbo.sysdatabases
WHERE name NOT IN ('master','model','msdb','tempdb') --não faremos backup dos bancos do SQL Server

OPEN db_cursor
FETCH NEXT FROM db_cursor INTO @name

WHILE @@FETCH_STATUS = 0
BEGIN
SET @fileName = @path + @name + '_' + @fileDate + '.BAK'
BACKUP DATABASE @name TO DISK = @fileName

FETCH NEXT FROM db_cursor INTO @name
END

CLOSE db_cursor
DEALLOCATE db_cursor

Simples e objetivo, resolve seu problema de fazer diversos backups de uma única vez e sem ter que ficar colocando nome por nome. Esse backup é um backup full. Você pode procurar formas de fazer backups incrementais e coisas assim…

Nos próximos talvez eu me aprofunde nisso.

FreeNAS 8.0

O que há de novo no 8.x

FreeNAS™ 8.x representa uma reimplementação completa desde a série .7 do FreeNAS™. Em outras palavras, FreeNAS™ foi reescrito “from scratch” e novas funcionalidades foram adicionadas de forma estável. Isso significa que nem todas as funcionalidades da versão .7 foram reimplementadas e nem todas as funcionalidades disponpíveis no FreeNAS™ .7 estarão disponíveis no FreeNAS™ 8.x.  As diferenças mais notáveis entre as duas versões seguem abaixo:

O versionamento mudou para seguir o mesmo número usado pela versão do FreeBSD. FreeNAS™ 8.0.1 é baseado no FreeBSD 8.2; esse branch do FreeNAS™ vem com funcionalidades completas.Esse número de versão irá ser incrementado depois para 8.1 e depois para 8.2.

• Baseado no NanoBSD no lugar do m0n0wall
• Design foi modificado de monolitico para modularizado, dessa forma permite a criação de plugins e o usuário pode instalar e configurar apenas os módulos que ele precisa.
• GUI reescrita em Django para permitir uma futura expanção.
• Nova GUI é a padrão, mas a antiga ainda esta disponível se você configurar no appname e depois FreeNAS™ system’s URL (e.g. http://192.168.1.1/services)
• Melhorado o sistema de permissões, usuários e grupos dos volumes e datasets.
• ZFS parametrização por dataset, assim como quotas, onde são adicionados
• LSI 6 gbps HBAs agora é suportado
• Migrado do rc.d init system
• Update dos ports do FreeBSD 8.2
• Adicionado suporte ao iSCSI
• Suporte do 3ware 6bps RAID controllers foram adicionados com um utilitario CLI utility, tw_cli, para gerenciamento 3ware RAID controller
• Adicionada habilidade para agendar snapshots, criar one-time snapshots, clone snapshots, que podem ser exportados e compartilhados como qualquer outro dataset, e é possível fazer rollback para um snapshot anterior

Notáveis funcionalidades oferecidas no FreeNAS™ 8.0.1 incluem:

• suporte a AFP, CIFS, FTP, NFS, SSH (incluindo SFTP), e TFTP como mecanismos de compartilhamento

• supports exporting file or device extents via iSCSI

• suporta Active Directory ou LDAP para autenticação de usuário

• suporta sistema de arquivos UFS2, incluindo gmirror, gstripe, e graid3

• suporta ZFS como principal sistema de arquivos, habilitando muitas funcionalidades não disponiveis UFS2 como sistema de cotas, snapshots, compressão, replicação, e datasets para compartilhamentos de subconfigurações de volumes via CIFS. Suporta zpool versão 15.

• procedimento de atualização tira vantagem da capacidade do NanoBSD de escrever o sistema operacional em uma partição inativa, permitindo uma fácil reversão de uma atualização indesejável.

• automática sistema de notificações sobre eventos do controlador LSI RAID  (requer serviço de e-mail configurado)

• Django interface grafica de gerenciamento

Hora de começar os testes com essa nova versão cheia de novidades? Sim e não. Eu indico que deem uma boa lida nos problemas conhecidos antes de partirem para fazer o upgrade dos NAS de vocês e também na comparação entre as duas versões.

Usuários conectados ao seus servidor MySQL

As vezes se faz extremamente necessário saber quem esta acessando nossa base de dados naquele momento. O MySQL apesar de ter ferramentas gráficas até bem maduras, diferente do postgreSQL(na minha opnião). Você terá sempre a possibilidade de usar tudo via terminal.
Apesar de conseguir fazer isso facilmente através do comando “SHOW PROCESSLIST”, quando possuo muitos processos fica um tanto difícil de conseguir verificar todos os usuários. A saída do “SHOW PROCESSLIST” seria a abaixo descreita no meu PC que não esta sendo acessado por ninguém além de mim:
mysql> SHOW PROCESSLIST;
+----+------+-----------+-------+---------+------+-------+------------------+
| Id | User |     Host  |   db  | Command | Time | State |      Info        |
+----+------+-----------+-------+---------+------+-------+------------------+
| 51 | root | localhost | teste | Query   |   0  |  NULL | SHOW PROCESSLIST |
+----+------+-----------+-------+---------+------+-------+------------------+
1 row in set (0.00 sec)

Podemos modificar para termos uma saída mais ou menos assim:
+-----------------+-----------------+----------+
| host_short      |       users     | count(*) |
+-----------------+-----------------+----------+
| slave1          | repl            |     1    |
| slave2          | repl            |     1    |
| localhost       | event_scheduler |     1    |
| 111.111.222.111 | root, foo       |     2    |
| 111.111.222.222 | appuser, bar    |     3    |
| 111.111.222.333 | appuser, moshe  |     9    |
+-----------------+-----------------+----------+

E para isso eu só preciso fazer uma simples query como esta descrita abaixo:
SELECT LEFT(host, IF(LOCATE(':', host), LOCATE(':', host), LENGTH(host) + 1) - 1
) AS
host_short,GROUP_CONCAT(DISTINCT USER) AS users,COUNT(*)
FROM information_schema.processlist
GROUP BY host_short
ORDER BY COUNT(*),host_short;

Essa saída mostrará de forma mais simples os usuários que encontram-se conectados ao seu banco.
fonte: sholimoid

Conectando MySQL e Pyhton

Fazer um script em Python que conecte-se ao MySQL é bastante simples. Mesmo que você não tenha tido qualquer experiência anterior com Python.
Claro que para prosseguirmos precisaremos ter o Python e o MySQL já instalados. Depois disso precisaremos fazer o import dos módulos MySQLdb e da sys. Para o MySQL você só precisará de um usuário que tenha permissão para conectart ao banco e realizar operações.
O post original o autor usa Python v2.5, MySQL version 5.5.8,com Mac OS X 10.6.8.Eu estou usando Python 2.6.5, MySQL 5.1.41 e Ubuntu 10.04.
Aqui estão os links caso vá realizar esse trabalho no Windows.

MySQL – http://dev.mysql.com/downloads
Python – www.python.org/getit/
MySQLdb module – http://sourceforge.net/projects/mysql-python/

#!/usr/bin/python
# versao.py – captura e mostra a versão do MySQL database server.
# importe os modulos do MySQLdb e sys
import MySQLdb
import sys
# Abra uma conexão com o banco de dados
# Tenha certeza de ter trocado o IP, usuario, senha e database para os seus.
connection = MySQLdb.connect (host = “192.168.1.1″, user = “username”, passwd = “password”, db = “database_name”)
# Inicie um cursor usando o método cursor()
cursor = connection.cursor ()
# Execute a expressão SQL
cursor.execute (“SELECT VERSION()”)
# capture a informação com o método fetchone().
row = cursor.fetchone ()
# mostre a informação[0]
print “Server version:”, row[0]
# Feche o cursor
cursor.close ()
# Feche a conexão
connection.close ()
# Saia do programa.
sys.exit()

Here is what the script looks like when I run it from the command line:
Server version: 5.1.41-3ubuntu12.10
A partir daí é só explorar as possibilidades já que assim é feita a conexão.
fonte: Scripting Mysql

Servidor Web Simples com Python

As vezes um servidor web se faz necessário para testes simples ou para pequenos compartilhamentos internos de sua intranet. E o tempo de setup de um servidor Apache ou ISS para uma tarefa tão trivial quanto essa pode não ser tão interessante. Depender a TI para configuração as vezes é um parto. E algumas outras vezes baixar e instalar tudo demandará tempo demais. Recomendo usar o servidor web que vem embutido no Python(confeço que não sabia até algum tempo).
Você só precisará de uma linha para configurá-lo:
$cd [diretorio]
$ python -m SimpleHTTPServer

Depois disso você terá um servidor web rodando na porta 8000 e será exibida a seguinte mensagem:
Serving HTTP on 0.0.0.0 port 8000 ...

Caso queira mudar a porta padrão do servidor web para um teste faça:
python -m SimpleHTTPServer 8080

Você poderá acessa-lo no seu navegador através do loopback(http://127.0.0.1:8080) ou pelo seu endereço IP (http://192.168.0.2:8080)

Simples não? Ainda farei alguns testes para ver o que isso aguenta. Não deve ser tanto, mas é interessante.

Fonte Original: [dicas-l]

Subprocess com Python – Tratamento de erros – parte 2

O valor de retorno do comando call() é o mesmo código de saída do programa que foi chamado. O comando de chamada é responsável por interpretar e detectar possiveis erros. Para tal a biblioteca subprocess possui o check_call(), que funciona de maneira parecida com o call(), porém no check_call() o código de saída é checado, e caso esse código indique um erro. Será feita uma chamada a uma exescessão chamada CalledProcessError.
Por exemplo:
import subprocess
subprocess.check_call(['false'])
Todos sabemos que não existe um comando false. Logo este comando retornará um erro na tela. Da seguinte forma:
>>> subprocess.check_call(['false'])
Traceback (most recent call last):
File "", line 1, in
File "/usr/lib/python2.7/subprocess.py", line 504, in check_call
raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command '['false']' returned non-zero exit status 1
Se nós tivessemos usado simplesmente o call(), nosso unico retorno seria o número 1 ao fim da execução do comando.
Ainda é possível fazer a captura de erros de outra forma. Mas colocarei isso em outro post.
fonte: doughellmann

Subprocess com Python – Executando comando externo- parte 1

Comunicão entre processos com Python.
O módulo subprocess permite você criar novos processos através de Python e assim se conectar aos seus inputs/outputs/erros pipes e obter seu código de retorno.

Rodar comando do shell:
Para executar um comando sem interagir com ele faça a chamada call() assim como faria com os.system()

import subprocess
# Simple command
subprocess.call(['ls', '-1'], shell=True)

Com o comando acima teremos a seguinte saída:
$ python subprocess_os_system.py

__init__.py
index.rst
interaction.py
repeater.py
signal_child.py
signal_parent.py
subprocess_check_call.py
subprocess_check_output.py
subprocess_check_output_error.py
subprocess_check_output_error_trap_output.py
subprocess_os_system.py
subprocess_pipes.py
subprocess_popen2.py
subprocess_popen3.py
subprocess_popen4.py
subprocess_popen_read.py
subprocess_popen_write.py
subprocess_shell_variables.py
subprocess_signal_parent_shell.py
subprocess_signal_setsid.py


E desde que tenhamos shell=True teremos acesso as variáveis de shell também.
import subprocess
# Command with shell expansion
subprocess.call('ls -1 $HOME', shell=True)


Dessa forma teremos a saída:
$ python subprocess_shell_variables.py

/home/maltzsama

Agora já sabemos executar um comando externo do sistema operacional ou mesmo um executavel qualquer usando subprocess, no próximo post veremos como fazer tratamento de erros em subprocess.

fonte: doughellmann.com

Gedit como IDE Python

Venho programando em Python há algum tempo, já até escrevi um post mostrando como usar o Komodo Edit como um editor Python.

Mas acredito que a maioria como eu usa Linux + Python para programar. Existem diversos editores no mundo Linux, muitos usam o EMAC(não me agrada muito), Vi, nano. Também existem algumas IDE’s como o proprio Eclipse e o Netbeans(acho que com suporte descontinuado). Mas sempre usei muito mais o Gedit, pela simplicidade e capacidade de extenção com plugins.

Então podemos começar colocando os plugins básicos do Gedit para facilitar nossas vidas. Algumas distribuições já vem instalados. Caso contrario faça:

Arch Linux

pacman -Sy gedit-plugins

ubuntu

sudo apt-get update
sudo apt-get install gedit-plugins

Após a instalação desses plugins padrões você poderá habilitalos da seguinte forma:

Editar->Preferências->Plugins

Depois de selecionar os principais plugins que serão utilizados, recomendo:

• Class Browser
• Embedded Terminal
• iPython Console
• Python Code Completion
• Python Indentation
• External Tools
• Bracket Completion

Os plugins que não são links é porque já foram automaticamente instalados com o pacote gnome-plugins. Os outros plugins que possuem links você precirá baixá-los e descompactalos na seguinte pasta.
.local/share/gedit/plugins/ ou /usr/lib/gedit/plugins/, se você quiser os plugins já instalados para qualquer usuário.

Você ainda tem a possibilidade de configurar o CVS, ou GIT para funcionar como controle de versão do seu projeto. Mas isso é assunto pra outro post. 

Instalação do Python no MS-DOS/FreeDOS

Existem interpretadores Python para diversas arquiteturas além de Linux, Windows e Mac. Você pode consultar as arquiteturas disponiveis aqui. Dentre elas esta a implementação para DOS. Mas porque instalar Python em MSDOS? Bem apesar de existir os famoses arquivos em lote ou bat-files sabemos que eles possuem muitas restrições e incapacidades e para conseguirmos transpor essa barreira podemos, mais uma vez, contar com Python.
Existe o site da caddit que disponibiliza a versão PythonD 2.4.2 Release 1.0 que é nada mais que um arquivo zip contendo os executaveis do Python.
Agora como colocar isso para funcionar? Inicialmente, claro, é preciso descompactar essa pasta dentro da sua partição DOS. Após isso feito é importante setar algumas coisas no autoexec.bat.


SET PATH=%PATH%;c:\pyd\bin\python
SET PYTHONHOME=c:\pyd\
SET PYTHONCASEOK=1


Depois de adicionar essas linhas ao final do autoexec.bat vc só precisará reiniar o computador e terá tudo pronto para usar.

O comando para iniciar o python no DOS é #pythond

wxFormBuilder

Nos últimos 2 ou 3 anos venho programado quase que exclusivamente em python. Uma linguagem muito divertida, fácil e produtiva por sinal. Mas uma coisa que sempre sofri um pouco foi ter que criar interfaces gráficas através de linha de comando que acabava sendo pouco produtivo no final das contas(me desculpem os fã-boys do shell, mas não é produtivo criar componente por componente).

Finalmente, depois de algum tempo desenvolvendo para modo-texto e fazendo interfaces o mais simples possível. Vi outro dia na lista de discursão de python um programa muitissimo interessante. O tal do wxFormBuilder, simplesmente perfeito.

 

  

Reclamei durante anos da forma que o Glade trabalhava, criando aquele xml dos infernos, ou mesmo usando aqueles pequenos projetos que transformava o XML em um código python eu achava simplesmnete chato.
O PyQT eu nunca usei de fato. Mas o WxFormBuilder parece ser fão da filosofia KISS(keep it simple, stupid).
Ele é capaz de gerar os códigos em C++, Pyhton e XML. Vale a pena conferir e ganhar ainda mais produtividade.