Bom galera essa semana deu uma olhada no pynotify, com ele é possivel gerar aquelas notificações que recemos quando o Icedove recebe um email, quando nossa bateria do note tá abrindo as pernas, enfim uma sério de possibilidades pra esse cara…
nesse exemplo que fiz imaginei o seguinte, tenho uma série de servidores e quero ser avisado quando algum deles não estiver respondendo…
aproveitei tbm a optionParse que pra mim é uma mão na roda e coloquei algumas opções pra chamar esse script
./script -t tempo_em_segundos
alem disso -v verssion -h help
gostei dele cara
bom vamos ao código:

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

# Criado em: "05/11/2009"
# Autor: MRSantos mrsantos@viaconnect.com.br
# Version:  1.3
#
# A espera não é uma esperaça vazia,
# possui a certeza interior de alcançar seu objetivo...
#
# 2009-11-08
#	+ acrescentado loop no script pra rodar eternamente 
#
# 2009-11-09
#	+ acrescentados optionParse para chamar o script com parametros
#	+ acrescentado icone na notificacao...

import sys
import os
import socket
from time import sleep
from optparse import OptionParser

try:
	import pynotify
except:
	os.system("clear")
	print "###########################################################"
	print "Modulo pynotfy nao instalado\napt-get install python-notify"
	print "###########################################################"
	sys.exit(0)

def verifica_status(host):
    	# por padrao tento nessa porta...
	port=22
	sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sock.settimeout(.5)

	testa=sock.connect_ex((host, port))
	if testa==0:
		return True
	else:
		sock.close()
		return False

def notificacao(title, msg):
	""" valores possiveis para os icones:
		printer - impressora
		dialog-warning - icone com exclamacao
		printer - impressora
		emblem-mail - email
		# acho que tem bem mais mas nao fui atrás 
		# tbm pode ser passado um caminho para uma imagem algo em torno de 72px de largura...
		# testei com uma foto minha ficou lindo... 
	"""
	icone = 'server'
	if pynotify.init("MRS"):
		n = pynotify.Notification(title, msg, icone)
		# descomente a linha de baixo e a notificacao fica até que alguem a feche...
		#n.set_timeout(pynotify.EXPIRES_NEVER)

		if not n.show():
		    print "Falha ao criar notificacao"

def main():
	hosts = {
		'Servidor1': '192.168.0.10',
		'Servidor2': '192.168.0.11',
		'Servidor3': '10.255.106.12',
		'Servidor do terra': '200.154.56.80'
		}

	for i in hosts.keys():
		if  not verifica_status(hosts[i]):
			 notificacao(i, "O servidor %s não está respondendo" % hosts[i])

if __name__ == '__main__':
	parser = OptionParser(usage="./%prog [-t]", version="%prog 1.0")
	parser.add_option('-t', '--time', help='Especifique um tempo para que que o script seja chamado novamente\nO tempo eh especificado em segundos...')
	options = parser.parse_args()[0]

	time_default=180 # se nao especificado tempo então é a cada 3 minutos

	while 1:
		main()
		if options.time:
			try:
				sleep(time)
			except:
				sleep(time_default)
		else:
				sleep(time_default)

Bom galera uma mudança que vou fazer é ele pegar os servidores de uma lista e nao do dicionario dentro do script, quando fizer atualizo o codifo aqui

Marcio

Semana passada peguei uma carona com o prima de uma amiga e no banco de trás do carro dele estava o livro C total e completo, quem nunca ouviu falar dele né…
tenho ele, mas sem nada melhor pra fazer começei a folhear ele e na pagina 282 eu acho tinha esse pequeno exemplo de como usar o printf pra formatar uma saída de dados, fiquei com ele na cabeça…
e num domingo a tarde desses da vida sem coisa melhor pra fazer fiz ele
tá sei que esse não é meu melhor post mas enfim tá ai

/*
* File:   main.c
* Author: mrsantos
*
* Created on 8 de Novembro de 2009, 16:47
*/

#include
#include 

int main(int argc, char** argv)
{
        int i;
            for(i=1;i <21; i++)
                            printf("%d \t%d \t%d\n", i, i*i, i*i*i);

                return (EXIT_SUCCESS);
}

Bom galera é isso, abraços a todos…

Tá sei que meus dois últimos posts foram sobre isso
mas um foi a função crua sem muito incremento…
o segundo foi uma versão gráfica usando GTK e desenhando tela no glade…
e esse resolvi escrever pra fazer uso do modulo optparse que é muito util pra quando queremos escrever script a maneira unix..
onde chamamos um script e passamos paramentros pro mesmo atraves de flags
nesse script usamos a flag -t pra definir tamanho, –version pra ver versão e -h pra mostrar um help…
bom sem mais delongas vamos ao script…

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

# Criado em: "04/11/2009"
# Autor: MRSantos mrsantos@viaconnect.com.br
#
# A espera não é uma esperaça vazia,
# possui a certeza interior de alcançar seu objetivo...

from os import system
from random import choice
from optparse import OptionParser

def gera_senha(tamanho):
	""" -=-=-=- Funcao responsavel por gerar a senha..."""
	caracters = '0123456789abcdefghijlmnopqrstuwvxz'
	tamanho = int(tamanho)

	passwd = ''
	for char in range(tamanho):
		passwd += choice(caracters)

	return passwd

def main():
	system('clear')
	# -=-=-=- Se nao informado tamanho da senha sera de 10 caracteres

	parser = OptionParser(usage="./%prog [-t] valor", version="%prog 1.0\nBy MRSANTOS")
	parser.add_option('-t', '--tamanho', help='Informe o tamanho desejado para senha')
	options = parser.parse_args()[0]

	try:
		tamanho = options.tamanho
		print "Senha=> " + gera_senha(tamanho)
	except:
		parser.error("""Valor informado nao eh numerico""")

if __name__ == '__main__':
	main()

Bom galera é isso, espero que seja util a alguem
abraços

Marcio

Há uns dias atrás mostrei como escrever um programinha pra gerar senha aleatória com python, bom resolvi montar uma interface gráfica pra ele usando gtk+glade+python o script que gera a senha é basicamente o mesmo que mostrei em outro post..
bom galera espero que gostem, na verdade vi vários desses na net e resolvi tbm codificar o meu
há ia me esquecendo a tela que desenhei no glade é super simples tem um caixa de texto que dei o nome de senha
um label que ira mostrar o resultado que dei o nome de resultado
e tem tbm 3 botoes,
um pra gerar a senha, outro com about só pra fazer uso das caixas de mensagens e tem tbm um botão pra sair do programa, qq duvida a respeito das telas me avisem, vou ver se coloca elas aqui tbm

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

# Criado em: "03/11/2009"
# Autor: MRSantos mrsantos@viaconnect.com.br
#
# A espera não é uma esperaça vazia,
# possui a certeza interior de alcançar seu objetivo...

try:
	import gtk
except:
	print "Modulo python-gtk2 nao encontrado: sudo apt-get install python-gtk2"

try:
	import gtk.glade
except:
	print "Modulo python-glade2 nao encontrado: sudo apt-get install python-glade2"

import os
from random import choice

class gera_senha(object):

	def __init__(self):

		os.system("clear")
		dir = ''
		file = 'gera_senha.glade'
		path = "%s%s" % (dir, file)
		self.interface = gtk.glade.XML(path)
		self.interface.signal_autoconnect(self)

		self.janela = self.interface.get_widget("janela")
		self.janela.set_title("Gerador de senhas by mrsantos")
		self.janela.connect("destroy", gtk.main_quit)

		self.tamanho = self.interface.get_widget("tamanho")
		self.tamanho.set_text("10")

		self.resultado = self.interface.get_widget("resultado")

	def mensagem(self, texto, janela=None):
		dialogo= gtk.MessageDialog(janela, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, texto)
		dialogo.set_markup(texto)
		dialogo.run()
		dialogo.destroy()

	def gera_senha(self):
		tamanho = None
		caracters = '0123456789abcdefghijlmnopqrstuwvxz'
		try:
			tamanho = int(self.tamanho.get_text())
		except:
			tamanho = 10

		passwd = ''
		for char in range(tamanho):
			passwd += choice(caracters)

		return passwd

	def on_sair_clicked(self, widget):
		gtk.main_quit()

	def on_about_clicked(self, widget):
		texto = "%s" % (15000, 'blue', "By mrsantos")
		self.mensagem(texto)

	def on_gera_clicked(self, widget):
		passwd = self.gera_senha()
		self.resultado.set_label("%s" % \
		(15000, 'orange', passwd))

	def main(self):
		self.janela.show_all()
		gtk.main()

if __name__ == '__main__':
	gs = gera_senha()
	gs.main()

É isso ai galera, espero que gostem, abraços

Marcio

1 de novembro de 2009, 18:15 domingo…
estou em casa fazendo um programa pra trocar senha de uma tabela no postgres, a idéia é a seguinte a cada x dias o script vai rodar e trocar a senha de uma determinada tabela no postgres…
bom não vou colocar todo o código aqui, mas vou por a parte que gera a senha aleatória em python que diga-se de passagem é muito simples…
bom esse é o post de numero 100 do meu blog, tinha a idéia de escrever algo mais elaborado mas não pensei em nada melhor
então sem mais delongas como dizem os gauchos, segue o código!

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

# Criado em: "01/11/2009"
# Autor: MRSantos mrsantos@viaconnect.com.br
#
# A espera não é uma esperaça vazia,
# possui a certeza interior de alcançar seu objetivo...

from random import choice

def gera_senha(tamanho):
        caracters = '0123456789abcdefghijlmnopqrstuwvxz'
        senha = ''
        for char in xrange(tamanho):
                senha += choice(caracters)
        return  senha

print sera_senha(10)

ao ser executado esse script vai mostrar algo como:
mrsantos@Cerrito ntpm>>$ ./troca_senhas.py
s7orn1gje5

Bom galera uma coisa que nas versões anteriores ao posgres 8.* era que não existia um alter table pra mudar o tipo da coluna e volta e meia tinha que realizar essa operação…
bom agora temos como fazer isso com um comando e não digamos com um metodo “alternativo”
então vamos ao comando

meuBanco=# ALTER TABLE minhaTabela ALTER column minhaColuna type newType;

Simples né

Bom galera por hora é isso e se não me falha a memoria esse é o post de numero 99..
rumo ao POST 100!!!

Marcio

Quando criamos uma tabela no postgres e queremos ter um campo de auto incremento estilo mysql a maneira mais simples é definir ele como sendo do tipo serial com isso o postgres irá criar uma sequencia que terá como nome nomeTabela_nomeCampo_seq, como será mostrado abaixo…
já tive que em algumas situações deixar alguns valores reservador pra uso administrativos por ex e as demais inserções terem
que começar por ex outro valor que não o 1 como seria de ser experado…
pra exemplificar isso vamos criar uma tabela

testes=# CREATE TABLE teste_sequence(id serial, nome varchar(15), idade int);
NOTA: CREATE TABLE criará sequência implícita “teste_sequence_id_seq” para coluna serial “teste_sequence.id”
CREATE TABLE

Ok tabela criada quero fazer com que os IDs dos inserts iniciem em 10
mas antes vamos dar uma olhada nessa sequence recem criada.
esqueceu o nome dela?
facil de ver
\ds
com esse comando iremos ver todas as sequences do banco que estamos conectados…
vejam o resultado do meu…

testes=# \ds
Lista de relações
Esquema | Nome | Tipo | Dono
———+———————–+———–+———-
public | pessoas_id_seq | sequência | postgres
public | teste_sequence_id_seq | sequência | postgres
(2 registros)

beleza agora quero ver em que valor que inicia essa minha sequence..
simples posso ver com um simples select nela como se fosse uma tabela comum, então vamos ao select

testes=# SELECT * from teste_sequence_id_seq;
sequence_name | last_value | increment_by | max_value | min_value | cache_value | log_cnt | is_cycled | is_called
———————–+————+————–+———————+———–+————-+———+———–+———–
teste_sequence_id_seq | 1 | 1 | 9223372036854775807 | 1 | 1 | 1 | f | f
(1 registro)

Bom agora vamos a mágica, vamos mudar o valor do last_value!
syntaxe é simples…
ALTER SEQUENCE nome_sequencia RESTART WITH novo_valor;
então para o que eu quero ficaria assim:

testes=# ALTER SEQUENCE teste_sequence_id_seq RESTART WITH 10;
ALTER SEQUENCE

vendo se realmente mudou

testes=# SELECT * from teste_sequence_id_seq;
sequence_name | last_value | increment_by | max_value | min_value | cache_value | log_cnt | is_cycled | is_called
———————–+————+————–+———————+———–+————-+———+———–+———–
teste_sequence_id_seq | 10 | 1 | 9223372036854775807 | 1 | 1 | 1 | f | f
(1 registro)

bom agora vamos fazer apenas uns inserts pra ver como ficou

testes=# insert into teste_sequence (nome, idade) values(‘marcio’, 33);
INSERT 0 1
testes=# insert into teste_sequence (nome, idade) values(‘cheila’, 37);
INSERT 0 1
testes=# insert into teste_sequence (nome, idade) values(‘vitoria’, 08);
INSERT 0 1
testes=# insert into teste_sequence (nome, idade) values(‘gui’, 16);
INSERT 0 1

e pra finalizar apenas um select na nossa tabela…

testes=# SELECT * from teste_sequence;
id | nome | idade
—-+———+——-
10 | marcio | 33
11 | cheila | 37
12 | vitoria | 8
13 | gui | 16
(4 registros)

Bom pessoal com isso vimos como mudar os valores de uma sequence
abraços até a próxima

Marcio

trocando papel de parede pela linha de comando…
Galera essa maneira é uma das inumeras maneiras que se deve ter de fazer isso
é apenas uma que gosto e que usei pra criar um script pra trocar aleatoria as imagens pra mim
a cada x tempo…
primeiro termos que ter o eterm instalado…
versões baseadas no debian basta instalar via apt…
sudo apt-get install eterm
bom com ele instalado temos um programinha que vem como acessório chamado Esetroot
para usar basta executar o seguinte comando:
Esetroot -f imagem.jpg
com a flag -f temos a imagem em full screen…
fica ai a dica…
dá pra fazer facil um script pra ficar trocando as imagens
abraços

Marcio

Opa galera as vezes precisamos executar algumas rotinas no postgres mas com outro usuário e fazer isso
atraves de um script, mas ai barramos um problema, vai pedir senha
uma maneira bem simples e elegante de resolver isso é criar no home do usuário que via executar o script um arquivo chamado
.pgpass com o seguinte conteudo…
hostname:port:database:username:password
há detalhe importante é que a permissão do arquivo de ser 600
simples né

abraços

Marcio

Galera olha o cenário vc no servidor de um cliente em produção fazendo um delete e sem querer vc esquece do bendito where..
quem nunca passou por algo parecido…
esquecer do where num delete ou update pode trazer muita dor de cabeça, que já passou por isso sabe do que estou falando…
uma maneira de revitar isso é usar o comado rollback…
ele aborta uma transaçao, bom então temos que iniciar uma transação
e como faremos isso no postgres?
bom iniciamos com o comando begin…
simples assim…
depois do comando begin seguimos com nossos sql normalmente pra finalizar uma transação usamos o comando commit, fazendo isso nossos SQLs serão efetivados em disco..
então seria algo assim:
begin;
SQLs;
commit;

vamos aos exemplos, primeiro vamos criar uma database;
pra testes…
create database testes;
após isso vamos nos conectar a base recem criada…
\c testes
agora criando uma tabela pra podermos fazer nossos testes…

create table pessoas(id serial, nome varchar(60), idade int);
agora vamos popular nossa tabela

insert into pessoas(nome, idade) values(‘marcio’, 33);
insert into pessoas(nome, idade) values(‘cheila’, 38);
insert into pessoas(nome, idade) values(‘amanda’, 24);
insert into pessoas(nome, idade) values(‘vitoria’, 08);
insert into pessoas(nome, idade) values(‘gui’, 16);
insert into pessoas(nome, idade) values(‘fox’, 31);

vendo nossos dados na tabela…
testes=# SELECT * from pessoas;
id | nome | idade
—-+———+——-
1 | marcio | 33
2 | cheila | 38
3 | amanda | 24
4 | vitoria | 8
5 | gui | 16
6 | fox | 31
(6 registros)

ok agora vamos a parte que nos interessa
vamos inciar uma transação, deletar alguns registros e voltar atras com rollback
segue o trecho…
testes=# begin;
BEGIN
testes=# DELETE FROM pessoas WHERE id > 3;
DELETE 3
testes=# SELECT * from pessoas;
id | nome | idade
—-+——–+——-
1 | marcio | 33
2 | cheila | 38
3 | amanda | 24
(3 registros)

testes=# ROLLBACK;
ROLLBACK
testes=# SELECT * from pessoas;
id | nome | idade
—-+———+——-
1 | marcio | 33
2 | cheila | 38
3 | amanda | 24
4 | vitoria | 8
5 | gui | 16
6 | fox | 31
(6 registros)

ufá tá tudo ali
viram pra evitar muita dor de cabeça podemos fazer com uma transação, não custa iniciar com um simples begin né…
agora se tudo tiver corrido bem basta dar um commit no final e tudo será gravado no banco, mas tenha certeza que tudo foi feito conforme vc queria mesmo…
bom galera tem muito mais pra falar sobre transações só arranhamos o conteudo, mas com isso já vamos evitar muita dor de cabeça né…
T+

Marcio