Blog de Ubuntu en Español Blog [no oficial] de Ubuntu en Español

Full Circle Pyhon Special Edition Volume 03

Descarga | FullCircle

Automatizando las conexiones ssh y scp con PLINK y PSCP (Windows y Unix)

Muchas veces nos interesa automatizar la conexion SSH o la descarga (download) o envio (upload) de un fichero/s mediante SCP en un servidor remoto del cual no tenemos acceso directo y por tanto tenemos que indicar un login y contraseña en el momento de ejecutar la conexion.

En Unix tenemos muchas formas de automatizar estos scripts (como p.ej usando expect) pero para simplificar el uso de este proceso y que pueda ser probado tambien por usuarios desde Windows (que me imagino les interesara bastante), hoy voy a hablar de las utilidades PSCP y PLINK incluidas en la pagina de descarga de PUTTY.

Para ello conectate a la pagina de Putty (http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html) y descargate los ficheros plink.exe y pscp.exe o en su

defecto el paquete putty.zip (que ya lleva incluidas todas las utilidades).

plink.exe lo emplearemos para automatizar las conexiones ssh (ejecuciones de comandos), y pscp.exe para las conexiones scp (upload y descarga de ficheros).

Para ello copia estos ficheros a alguna ruta del path, o p.ej a C:/Windows/System32 con lo que ya podrás acceder a ellos directamente desde la consola de Windows.

En el caso de que uses Ubuntu, puedes insalar estos mismos comandos (plink y pscp, en este caso) si instalamos el paquete putty-tools:

sudo apt-get install putty-tools

Veamos como podemos usarlos para ejecutar un comando remoto o enviar ficheros pasando directamente el usuario y la password:

Ejemplo de uso de pscp:

pscp.exe -pw jose TUTORIAL.txt jose@127.0.0.1:/export/TUTORIALES/COMPARTIDO

Aqui p.ejemplo estoy subiendo el fichero TUTORIAL.txt (local) a la ruta remota /export/TUTORIALES/COMPARTIDO de la maquina 127.0.0.1 para el usuario jose y password jose.

Como veis la sintaxis es practicamente identica a la de el comando scp. Si ejecutais plink o pscp sin indicar nada, ya os muestra la ayudan en linea.

Ejemplo de uso de plink:

plink.exe -pw jose jose@127.0.0.1 ls -l

En este caso conecto a la maquina remota 127.0.0.1 como usuario jose, password jose y ejecuto el comando “ls -l”

Tambien podemos escribir un script de comandos y ejecutarlo con el parametro -m. Ejemplo:

plink -pw jose -m BACKUP.sh jose@127.0.0.1

Donde BACKUP.sh es el fichero que contiene la lista de todos los comandos que queremos ejecutar en remoto.

He escrito tambien una pequeña libreria en Python de automatización donde empleo estas utilidades para ejecutar conexiones ssh o scp remotas desde scripting.

La libreria vale tanto para Windows como Linux sin tocar nada pues ya detecta el Sistema operativo que se esta utilizando, unicamente requiere que plink.exe y

pscp.exe esten en el path de Windows o plink y pscp instalados en Linux.

La libreria es una idea de algo más grande que estoy creando para hacer muchas más cosas: lectura de parametros desde Excel. Ejecucion de consultas sobre base de datos Oracle/MySQL/Sqlite.

Filtrado de ficheros, evaluacion de resultados, etc…

En este caso dejo los ficheros: DEMO.py y WOLF.py, DEMO contiene un ejemplillo y en las capturas de pantalla podreis ver que se ejecuta correctamente tanto en Windows como en Linux.

Nota: Si usais Windows y necesitais un servidor SSH para vuestras pruebas locales, podeis usar MobaSSH (http://mobassh.mobatek.net/)

WOLF.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Wolf: Libreria de Automatizacion
Version 1.0 - Creada en Diciembre 2011
@author: lobo
Nota: Iremos ampliando poco a poco sus funciones
Version 1.0 
- Soporte de SCP y SSH mediante las utilidades plink.exe y pscp.exe en Windows o plink y pscp (putty-tools) en Linux
'''
from subprocess import call
from platform import system
import os
class Wolf(object):
    '''
    Limpia la pantalla  
    '''  
    def cls(self):</p>
         os = system()  
        if os == 'Linux':  
            call('clear', shell = True)  
        elif os == 'Windows':  
            call('cls', shell = True)</p>
     '''  
    Crea una variable de entorno  
    '''  
    def export(self,key,value):  
        if (value==None):  
            value="-"  
        os.environ[key]=value  
        print("export "+key+"="+value)</p>
     '''  
    Crea un fichero con el contenido indicado, Expande las variables de entorno.  
    '''  
    def mensaje(self,contenido,fpath):  
        try:  
            f=open(fpath,"wb")  
            contenido=os.path.expandvars(contenido)  
            contenido=os.path.expandvars(contenido)  
            f.write(contenido)  
            f.close()  
            print(fpath+" generado.")  
        except Exception,err:  
            print("Error: "+str(err))</p>
     '''  
    Ejecuta comandos remoto mediante SSH  
    '''  
    def ssh(self,host,user,password,cmds):  
        PLINK_STRING="plink"  
        so = system()  
        if so == 'Linux':  
            PLINK_STRING="plink"  
        elif so == 'Windows':  
            PLINK_STRING="plink.exe"</p>
         #cmds=os.path.expandvars(cmds)  
        #cmds=os.path.expandvars(cmds)</p>
         comando=PLINK_STRING+" "+"-pw "+password+" "+user+"@"+host+" "+cmds  
        print("debug: "+comando)  
        try:  
            os.system(comando)  
        except Exception,err:  
            print("Error: "+str(err))</p>
     '''  
    Ejecuta en remoto el contenido del script indicado  
    '''  
    def sshScript(self,host,user,password,script,fOut=None):  
        PLINK_STRING="plink"  
        so = system()  
        if so == 'Linux':  
            PLINK_STRING="plink"  
        elif so == 'Windows':  
            PLINK_STRING="plink.exe"</p>
         #cmds=os.path.expandvars(cmds)  
        #cmds=os.path.expandvars(cmds)</p>
         comando=PLINK_STRING+" "+"-pw "+password+" -m "+script+" "+user+"@"+host+" "  
        print("debug: "+comando)  
        try:</p>
             stdout = os.popen(comando)  
            OUT=stdout.read()  
            print (OUT)  
            if (fOut!=None):  
                f=open(fOut,"wb")  
                f.write(OUT)  
                f.close()</p>
         except Exception,err:  
            print("Error: "+str(err))</p>
     '''  
    Sube un fichero a remoto  
    '''  
    def upload(self,host,user,password,localfile,remotefile):  
        PSCP_STRING="pscp"  
        so = system()  
        if so == 'Linux':  
            PSCP_STRING="pscp"  
        elif so == 'Windows':  
            PSCP_STRING="pscp.exe"  
        localfile=os.path.expandvars(localfile)  
        localfile=os.path.expandvars(localfile)  
        remotefile=os.path.expandvars(remotefile)  
        remotefile=os.path.expandvars(remotefile)  
        comando=PSCP_STRING+" "+"-pw "+password+" "+localfile+" "+user+"@"+host+":"+remotefile  
        print("debug: "+comando)  
        try:  
            os.system(comando)  
        except Exception,err:  
            print("Error: "+str(err))</p>
     '''  
    Descarga un fichero remoto  
    '''  
    def download(self,host,user,password,remotefile,localfile):  
        PSCP_STRING="pscp"  
        so = system()  
        if so == 'Linux':  
            PSCP_STRING="pscp"  
        elif so == 'Windows':  
            PSCP_STRING="pscp.exe"  
        localfile=os.path.expandvars(localfile)  
        localfile=os.path.expandvars(localfile)  
        remotefile=os.path.expandvars(remotefile)  
        remotefile=os.path.expandvars(remotefile)  
        comando=PSCP_STRING+" "+"-pw "+password+" "+user+"@"+host+":"+remotefile+" "+localfile  
        print("debug: "+comando)  
        try:  
            os.system(comando)  
        except Exception,err:  
            print("Error: "+str(err))</p>
     '''  
    Imprime un texto con expansion de variables  
    '''  
    def echo(self,string):  
        string=os.path.expandvars(string);  
        string=os.path.expandvars(string);  
        print(string)</p>
     '''  
    Constructor  
    '''  
    def __init__(self):  
        '''  
        Constructor  
        '''  
        print("Wolf: Libreria de Automatizacion v1.0")

DEMO.py

#!/usr/bin/python
# Importamos la libreria de Automatizacion
from Wolf import Wolf
# Creamos una instancia de la clase
s=Wolf()
# Indicamos los datos de Acceso a la maquina remota
host="AQUI TU HOST"
user="AQUI TU USER"
password="AQUI TU PASSWORD"
# EJEMPLO_1 : Creamos un script con los comandos a ejecutar.
s.mensaje("cd ${HOME}; cal","SCRIPT_01.sh")
# EJEMPLO_2: Ejecutamos en remoto el script anterior y guardamos sus trazas en Local (fichero TRAZAS.log)
s.sshScript(host,user,password,"SCRIPT_01.sh","TRAZAS.log")
s.echo("Mi directorio HOME es ${HOME}")
# EJEMPLO_3: Descargamos de remoto un fichero mediante pscp
s.download(host, user, password, "/tmp/SSH.log", "./SSH_recuperado.log")

Referencias: http://linux.die.net/man/1/plink | http://linux.die.net/man/1/pscp

Gedit Multi Terminal Plugin

Gedit Multiple Terminal plugin es un plugin para Gedit que nos permite disponer de varias pestañas para controlar más de un terminal ( o consola) empotrada, al más puro estilo de kate.
Aviso que no me ha funcionado en todas las instalaciones de Ubuntu 11.04/11.10 (puede que por las dependencias), aunque en su defecto, la instalación consiste únicamente en copiar los archivos:  mterminal.py y mterminal.gedit-plugin al directorio ~/.gnome2/gedit/plugins. entonces deshabilitas el plugin Terminal plugin si lo tuvieras activado (sudo apt-get install gedit-plugins) y activas el plugin mterminal recien instalado.

Para abrir o cerrar las multiples terminales basta con hacer click derecho en una de las terminales y aparecera un menu emergente.

Enlace | gedit-mterminal

Vala Toys for Gedit

Vala Toys para Gedit es una colección experimental de plugins que extienden el editor Gedit para permitir una mejor programación en el lenguaje Vala.

Para instalarlo desde consola podemos ejecutar:

$sudo apt-get install gedit-valatoys-plugin

Enlace | vtg

Crear, Leer y Modificar una Hoja Excel con Python

Trabajar con hojas excel desde python es bastante sencillo si hacemos uso de unas cuantos modulos que nos
facilitan esta labor, estos son:

- xlwt: utilizada para escribir excel
- xlrd: utilizada para modificar excel
- xlutils: require de las anteriores y son una serie de utilidades que nos permiten entre otras cosas,
copiar o modificar una excel previa.

Puedes descargarlas desde el siguiente enlace: http://www.python-excel.org/

La instalacion es tan simple como descomprimir el .tar.gz del modulo y ejecutar:

$ sudo python setup.py install

desde el directorio donde se descomprimen. Tambien puedes usar otras utilidades como easy_install o pip
para instalar mas facilmente modulos en Python:

Ejemplo:

$ sudo apt-get install python-setuptools
$ sudo easy_install xlwt

En Ubuntu tambien podemos instalar esos modulos directamente desde repositorio:

$ sudo apt-get install python-xlwt ptthon-xlrd

Nota: Antes de seguir con los ejemplos deberas tener instalados los 3 modulos: xlwt, xlrd y xlutils.

Primer ejemplo: Crear una hoja Excel

# Ejemplo de creacion de hoja Excel
import xlwt
from datetime import datetime
style0 = xlwt.easyxf('font: name Times New Roman, colour red, bold on')
style1 = xlwt.easyxf('',num_format_str='DD-MMM-YY')
wb = xlwt.Workbook()
ws = wb.add_sheet('A Test Sheet',cell_overwrite_ok=True)
ws.write(0, 0, 'Test', style0)
ws.write(1, 0, datetime.now(), style1)
ws.write(2, 0, 4)
ws.write(2, 1, 1)
ws.write(2, 2, xlwt.Formula("A3+B3"))
wb.save('example.xls')

En el codigo, importamos el modulo xlwt (import xwlt) que nos permite acceder a la libreria correspondiente
para escribir la hoja excel.
y basicamente definimos 2 estilos para la hoja. Uno con fuente de texto Times New Roman, negrita y color rojo
y otro para formatear una fecha.

Despues creamos el fichero excel:

wb = xlwt.Workbook()

Le añadimos una pestaña llamada “A teest sheet”:

ws = wb.add_sheet('A Test Sheet',cell_overwrite_ok=True)

nota: la opcion “cell_overwrite_ok=True” es para que permita sobreescribir celdas.

Y ya estamos listos para ir escribiendo valores en la excel. Por ejemplo:

ws.write(1, 0, datetime.now(), style1)

escribe en la posicion columna 0, fila 1 la fecha actual y aplicandole el estilo style1 definido anteriormente.

Tambien podemos escribir formulas:

ws.write(2, 2, xlwt.Formula("A3+B3"))

Y por ultimo cuando nos cansemos de añadir valores, guardamos finalmente la excel en la ruta deseada:

wb.save('example.xls')

Segundo Ejemplo: Leer una hoja Excel

Esta vez partimos del caso inverso. Creada ya una excel, queremos leer sus valores.

# Ejemplo de lectura de hoja Excel
import xlrd
book = xlrd.open_workbook("example.xls")
print "The number of worksheets is", book.nsheets
print "Worksheet name(s):", book.sheet_names()
sh = book.sheet_by_index(0)
print sh.name, sh.nrows, sh.ncols
print "Cell (2,0) is: ", sh.cell_value(rowx=2, colx=0)
for rx in range(sh.nrows):
print sh.row(rx)

Primero importamos el modulo “xlrd” con:

import xlrd

Eso nos permitira acceder a las funciones que nos permiten leer desde una excel.

Despues abrimos la excel:

book = xlrd.open_workbook("example.xls")

Con eso ya por ejemplo podemos imprimir el numero de pestañas (hojas de trabajo) que tiene o sus nombres:

print "The number of worksheets is", book.nsheets
print "Worksheet name(s):", book.sheet_names()

Si queremos leer los valores de alguna pestaña, primero la referenciamos, por ejemplo para
acceder a la primera:

sh = book.sheet_by_index(0)

Imprimimos su nombre y el numero de filas y columnas que la componen:

print sh.name, sh.nrows, sh.ncols

Si por ejemplo queremos acceder a la fila=2, columna=0 para recuperar su valor:

print "Cell (2,0) is: ", sh.cell_value(rowx=2, colx=0)

Y por ultimo, podemos recorrer la hoja entera para imprimir todos los valores de sus celdas:

for rx in range(sh.nrows):
print sh.row(rx)

Tercer Ejemplo: Modificar una hoja Excel

El problema de xlrd y xlwt es que no podemos por ejemplo abrir una excel ya creada, editarla y volver a guardarla,
si no que debemos abrir una copia de la excel original, modificarla y entonces ya guardarla con un nuevo nombre,
para todo esto, nos ayuda el ultimo modulo (xlutils).

Ejemplo:

# Ejemplo de modificacion de hoja Excel
from xlrd import open_workbook
from xlutils.copy import copy
rb = open_workbook('example.xls',formatting_info=True)
wb = copy(rb)
ws = wb.get_sheet(0)
ws.write(0,0,"I'm only changing cell A1")
wb.save('example2.xls')

En el ejemplo: hemos abierto una copia de la excel llamada “example.xls”

rb = open_workbook('example.xls',formatting_info=True)
wb = copy(rb)

Accedemos a la primera pestaña de la excel:

ws = wb.get_sheet(0)

Modificamos el valor de una celda:

ws.write(0,0,"I'm only changing cell A1")

Y ya la guardamos con otro nombre.

wb.save('example2.xls')

El efecto es el mismo, es como si hubieramos editado sobre la excel original.

Evidentemente este es un pequeño articulo introductorio y existen muchas mas funciones que nos pueden ser
de mucha utilidad, consultando la documentacion de las librerias podemos obtener mas informacion.

Aun asi dejo un par de enlaces adicionales, para completar la informacion proporcionada:

Enlace | Write Excel files with Python | Excel SpreadSheets and Python | Using python to write to an Excel | xlwt CheatSheet | Python and Excel