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.

• 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

• 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.

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

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

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

 

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.