Script para montar compartidos windows

19 05 2010

Desde Ubuntu (Linux) es mucho mas dificil montar archivos compartidos desde Windows y mucho mas cuando la version es Windows 7, por su nuevo sistema de compartido.

Para ello me hecho otro Script (si, otro a la lista) utilizando Python (si si me gusta Python para scripts), lo que hice fue envolver el montado del compartido pero esta vez si tener que scribir el password del usuario para conectarse a la vista de todos (eso mal, muy mal 😦 ).


#!/usr/bin/env python

import getpass, getopt, sys, os

__author__ = "Edder Rojas <edder.rojas@gmail.com"
__version__ = "0.2"

class SmbMount():

    def __init__(self, mnt_src, mnt_dest, username, password):
        self.mnt_src = mnt_src
        
        if not os.path.exists(mnt_dest):
            raise IOError("Path doesn't exist")
            
        self.mnt_dest = mnt_dest
        self.username = username
        self.password = password
        self.user = getpass.getuser()
        
    def mount(self):
        command =  "sudo smbmount " 
        command += self.mnt_src + " " 
        command += self.mnt_dest + " "
        command += "-o user=" + self.username + ","
        command += "pass=" + self.password + ","
        command += "uid=" + self.user + ","
        command += "iocharset=utf8"
        
        result = os.system(command)


if __name__ == "__main__":
    args = sys.argv
    if ( len(args) < 4 ):
        print (
                args[0].replace("./", "").split("/")[-1] + " " 
                + __version__
                + " <remote folder> <mount folder> <username>"
               )
    else:
        mnt_src = args[1]
        mnt_dest = args[2]
        username = args[3]
        password = getpass.getpass()
        smbMount = SmbMount(mnt_src, mnt_dest, username, password)
        smbMount.mount()

Basicamente hace de wrapper para smbmount y le da permisos al usuario actual para poder escribir, leer y todo el asunto. Algo a notar es que necesita el comando smbmount, además permisos de Root y por ultimo una carpeta de destino; mi conveción para esto, yo uso la carpeta /media y creo una carpeta con el mismo nombre del maquina a la que me estoy conectado y luego le doy permisos a mi usuario para usarlo:

mkdir /media/WinTarro
chown usuario.grupo /media/WinTarro

Ya con eso se podria usar el comando.

Anuncios




AppIndicator de Servicios

17 05 2010

Retomo este blog de vuelta, he tenido mucho con el trabajo y la Universidad y ahora es tiempo de seguir con lo que voy encontrando, pero ahora el enfoque no es a lo que se puede encontrar un rato googleando, quiero aportar con mi granito de arena con lo que yo mismo voy haciendo (programitas y scripts 🙂 ), asi que comienzo:

Asi como lo dice el titulo agrego un AppIndicator que muestra servicios corriendo (solo para Ubuntu 10.04 en adelante), para los que no saben que son AppIndicators, es basicamente la implementación de la bandeja del sistema pero mas usable, con una interface mas estandar y lo mejor de todo mucho mas fácil de programar (soy programador no puedo evitarlo 😛 ), ahora bien tengo una EeePC 900, como muchos saben es una netbook con pocos recursos (y vieja) por lo que tengo que quitar ciertos procesos para que cargue mas rapido en el booteo el sistema (de ahi sale porque hice la aplicacion), como nota el programa entero no lo hice yo, es de Sami Khan, Etopian Inc. http://www.etopian.com y yo le agregue el app-indicator y use el icono de gnome-do que viene en el set default de iconos en ubuntu Lucid, bueno ya que explique voy a lo importante, el codigo:

#!/usr/bin/env python

# Gnome Tray Services - For Ubuntu and Debian Distros
# A simple application to help start and stop services from the tray.

# Sami Khan, Etopian Inc. http://www.etopian.com
# Start and shutdown init.d services.
# GPL Version 3 - http://www.fsf.org/licensing/licenses/gpl-3.0.html
# AppIndicator by Edder Rojas https://paindev.wordpress.com

# Todo:
# - Scan for running services each time the menu opens, so if services are
# started manually from the console, it knows about them.
# - Make a dialog for adding/removing any init.d service from the menu.s
# - Perhaps wrap the Services into a Class.

# Configure services
services = ['apache2',
           ['mysql', '/var/run/mysqld/mysqld.pid']]
           # 'memcached',
           #['cups', '/var/run/cups/cupsd.pid'],
           #['mpd', '/var/run/mpd/pid'],
#            'gpsd',
#            'bluetooth',
           #['bind9', '/var/run/bind/run/named.pid']]

# === Don't edit below here, unless you know what you are doing! ===

import gtk
import pygtk
import subprocess
import os.path
import time
import appindicator
import pynotify
from types import *

class TrayServicesIndicator:

	#available services
	services = ['apache2',
			   ['mysql', '/var/run/mysqld/mysqld.sock']]

	# class constructor
	def __init__(self):
		self.ind = appindicator.Indicator(
				       "example-simple-client",
				       "gnome-do-symbolic",
				       appindicator.CATEGORY_APPLICATION_STATUS)

		self.ind.set_status(appindicator.STATUS_ACTIVE)
		self.ind.set_attention_icon("gnome-do-symbolic")

		#create a menu
		self.menu = gtk.Menu()

		for service in self.services:
			if(type(service) is ListType):
				service_name = service[0]
				service_pid_file = service[1]
			else:
				service_name = service

			if(self.service_is_running(service)):
				self.menu.append(self.service_menu_item_create(service, service_name, self.menu, 'stop'))
			else:
				self.menu.append(self.service_menu_item_create(service, service_name, self.menu, 'start'))
		#menu separator
		#menuItem = gtk.SeparatorMenuItem()
		#self.menu.append(menuItem)
		#menuItem.show()

		# quit menu
		#menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
		#menuItem.connect('activate', self.quit_cb, self.menu)
		#menuItem.show()
		#self.menu.append(menuItem)

		self.ind.set_menu(self.menu)

	# quit application by menu
	def quit_cb(self, widget, data = None):
		if data:
			data.set_visible(False)
		gtk.main_quit()

	# run a notification
	def notify(self, service, msg):
		n = pynotify.Notification(service+" "+msg)
		n.show()

	# call to status change
	def service_change_state(self, path, op):
		subprocess.call(['gksudo','--description','Tray Indicator Services','/etc/init.d/'+path, op])

	# Check if the process is running
	def service_is_running(self, service):
		if(type(service) is ListType):
			service_pid_path = service[1]
			if (os.path.exists(service_pid_path)):
				return 1
		else:
			if(os.path.exists('/var/run/'+service+'.pid')):
				return 1
		return 0

	# alternate service widget base on his state
	def toggle_service(self, widget, service, service_name, menu, op):
		if(self.service_is_running(service)):
			self.service_change_state(service_name, 'stop')
			widget.set_active(False)
			self.notify(service_name, "not running")
		else:
			self.service_change_state(service_name, 'start')
			widget.set_active(True)
			self.notify(service_name, "running")

	# Create a menu item based on a process
	def service_menu_item_create(self, service, service_name, menu, op):
		menuItem = gtk.CheckMenuItem(service_name)
		if (self.service_is_running(service)):
			menuItem.set_active(True)
		else:
			menuItem.set_active(False)

		menuItem.connect("activate", self.toggle_service, service, service_name, menu, op)
		menuItem.show()

		return menuItem

# main gtk entry
def main():
	gtk.main()
	return 0

# application if runned directly
if __name__ == '__main__':
	trayServicesIndicator = TrayServicesIndicator()
	main()

Por el momento solo va a mostrar 2 servicios (apache y mysql), para agregar servicios es nada mas de agregarlos en el ejecutable la variable servicios, ademas este script puede ser corrido directamente con solo darle permisos de ejecución, o bien para los mas traviesos pueden importarlo como una clases e interactuar, la idea es aprender mientras se hace la vida más fácil, en lo personal es genial para reiniciar servicios 🙂





Script para ocultar los paneles en Gnome

18 01 2009

Creo que habia comentado que tengo una Eee PC 900, la cual es muy comoda para trabajar, además no tengo las manos muy grandes y no me es muy incomo el teclado.

El punto es que a veces la aplicaciones en Gnome las hacen un poco más grandes que mi monitor puede mostrar, a veces es por poco que no se ve completa, para ello decidí crear un script en Python que oculta el panel de arriba y de abajo (es la configuración por defecto de gnome), éste es el script:

#!/usr/bin/env python

import os

command = "gconftool-2 --set /apps/panel/toplevels/panel_1/auto_hide --type bool "
command2 = "gconftool-2 --set /apps/panel/toplevels/panel_0/auto_hide --type bool "

results = os.popen("gconftool-2 --get /apps/panel/toplevels/panel_1/auto_hide").read()
str.replace(results, "\n","")

if results == "false\n":
        os.popen(command + "1")
        os.popen(command2 + "1")
else:
        os.popen(command + "0")
        os.popen(command2 + "0")

Para saber cuales son los paneles en cuestion, porque varian de maquina en maquina si se han removido y re-agregado anteriormente, hay que abrir el gconf-editor se puede abrir pusaldo la combinación de teclas Alt+F2 y escribiendo la caja de texto gconf-editor.

Ya con la aplicación abierta hay que expandir las carpetas apps->panel->toplevels->panel0, como dije anteriormente puede variar esos nombres, una forma de saber si son esos es darle click de las carpetas de alguno de los paneles y darle click en el checkbox auto_hide si el panel llegase a ocultarse significa que ese el correcto y hay que poner el nombre en el script, se repite el mismo proceso para el otro panel ( si tuvieran uno mas).

Un tip extra, es que por defecto los paneles ocultos, se siguen mostrando una parte (6 pixeles), eso se modifica en la propiedad de nuevo de alguno de los paneles auto_hide_size, yo casi siempre lo pongo en 0, asi no se muestran del todo.





Script en python para hacer respaldos

5 10 2008

Ultimamente me ha interesado bastante python tanto asi, que me di la tarea de ir haciendo programitas (scripts) que hagan cosas automaticamente por mi.

Unas de las ideas que se me presentó es hacer un respaldo, ya que en la computadora que tengo en el trabajo ultimamente me ha dado problemas, creo que es el disco duro que está en las últimas, por dicha nos van a cambiar la maquinas 😀

Bueno volviendo al tema, me dieron acceso (ssh) a otro maquina para que subiera mis respaldos, como un respaldo es algo que se hace monotonamente todo el tiempo decidi hacer el script pero en python, normalmente estos tipos de scripts se hacen en shell (bash, sh, awk, perl, etc), personalmente me gusta bastante python, por lo que investigue como hacer llamadas al sistema y éste es el resultado:

import os

# Definicion de la variables que para preconfigurar
backupDir = '/home/edder/Backups/'
backupUser = 'backup'
backupPass = '*******'
summary = ""
backupDest = 'edder@192.168.0.x:/home/edder/backups/'
webroot = '/var/www/'

#funcion que ejecuta un comando y devuelve el resultado
def run_command(command, message):
	results = os.system(command)

	if results == 0:
		return message + '\n'
	else:
		return str(results) + "\n"

# comando y mensaje que hace un respaldo de mysql
command = 'mysqldump -u ' + backupUser + ' -p'+ backupPass + ' website > ' + backupDir + 'website.sql'
message = "Backup completed of the database\n"
summary += run_command(command, message)

#comando que respalda un website (apache) en un tar.gz
command = 'tar -pzcf ' + backupDir + '/website.tar.gz ' + webroot+ 'website'
message = "Backup of page website completed\n"
summary += run_command(command, message)

# comando que copia los respaldos via ssh a otra maquina via rsync
command = 'rsync -avz ' + backupDir + ' ' + backupDest
message = "Backup stored in the remote computer\n"
summary += run_command(command, message)

# los resultados obtenidos
print summary

Al script le falta pulir pero se entiene la esencia de lo que hace 😉