Instalar Tonido en Manjaro (Archlinux) - Archivos en la nube

Lo de hoy son los servicios en la nube, servicios como Dropbox, google drive, Ubuntu One, BOX, todos servicios en la nube que ofrecen almacenamiento, ya sea gratuito o con algún plan de pago.
Pero si queremos implementar una solución en la nube, propia tenemos opciones como ownCloud  una solución libre y gratuita que nos permite implementar un acceso a nuestros archivos desde cualquier parte.

Otra solución es Tonido al igual que ownCloud es un servidor que da acceso remoto a nuestros archivos, es multiplataforma, y cuenta con apps para iOS, Android, blackberry, windows phone.
Una de las caracteristicas que probé con Tonido, es el streaming de video de los archivos de mi equipo a mi dispositivo(un iPad), soporta gran variedad de archivos, y si no lo soporta tiene la opción de codificarlos (del lado del servidor) para poder reproducirlos, y dependiendo de nuestra conexión bajar el bitrate para una reproducción mas fluida.

Ponerlo a trabajar es muy fácil, lo primero es descargar la aplicación de escritorio e instalarla. En su sitio de descargas ofrece la aplicación para las diferentes plataformas: Windows, Linux, Mac
Para Linux ofrece los paquetes DEB que funcionan con Ubuntu, para el caso de Manjaro (Archlinux) podemos encontrar el paquete en el repositorio de AUR.

La instalación es tan sencilla como:

$ yaourt -S tonido

Nota: a la fecha en el paquete de AUR no muestra una dependencia de la aplicación que es: libjpeg6
instalamos igual desde AUR esta dependencia:

$ yaourt -S libjpeg6

una vez instalado creamos un enlace simbolico al script de inicio del servidor:

$ sudo ln -s /usr/share/tonido/tonido.sh /usr/bin/tonido

y cuando queramos iniciar el servicio tecleamos el siguiente comando:

$ tonido start

y con esto se iniciará el servidor, una vez iniciado entramos desde nuestro navegador a la siguiente dirección:
http://localhost:10001

y nos mostrará la pantalla de inicio de configuración del servidor, de aquí en adelante es muy sencilla su configuración, creamos nuestra cuenta en tonido y listo.

Imagen de panel principal del servidor

Tonido se encarga del DNS para nuestro servidor, así que podremos acceder a nuestro servidor con la dirección de nuestra cuenta que es algo así:  tuusuario.tonidoid.com

Imagen de la app de iPad recibiendo el stream de video desde mi equipo.

Desbloquear deposito de claves automático en Manjaro Linux (Archlinux)

Uno de los recientes cambios en Manjaro fue el uso del display manager LXDM remplazando a GDM, es mas ligero y un poco mas configurable en apariencia que GDM.

En mi instalación de Manjaro 0.8.4. uno de los primeros programas en instalar es Google Chrome, yo utilizo la sincronización de google para mantener mis contraseñas y favoritos entre los dispositivos que uso, lo que no sabía es que google chrome hace uso del gnome keyring para cifrar tus contraseñas y datos cifrados por chrome, y al iniciar sesión, el deposito de claves me pedía la contraseña para desbloquearse.

Leyendo y buscando soluciones, todos te dicen que dejes sin contraseña el deposito de claves, es lo mas fácil, pero no lo mas seguro ni recomendable.

La solución para Manjaro y los que usen LXDM es agregar al archivo "lxdm" en la siguiente ruta

$ sudo nano /etc/pam.d/lxdm

y agregar las siguientes lineas:

auth               optional                   pam_gnome_keyring.so
session          optional                   pam_gnome_keyring.so auto_start

Guardamos los cambios y reiniciamos, y ya no pedirá la contraseña del deposito de claves.

Activando la transferencia de archivos vía Bluetooth en Manjaro Linux

Si cuentan con Bluetooth en su equipo, el servicio debería de quedar instalado y listo para usarse al momento de la instalación del sistema, desde el applet de Bluetooth de cinnamon podemos activar y desactivar este. Bien, si queremos transferir un archivo a nuestro equipo desde algún otro dispositivo como un teléfono celular, debemos activar la recepción de archivos vía Bluetooth, esto lo podemos hacer desde una terminal, lanzamos la configuración de archivos de gnome:

$ gnome-file-share-properties

Y ahí seleccionamos la casilla de "Recibir los archivos por Bluetooth en la carpeta Descargas"

Y cerramos la ventana, con esto ya podremos transferir nuestros archivos a nuestro equipo.

Crear y agregar un servicio a SystemD en Manjaro (Archlinux) - Subversion

Hora de configurar un servidor de desarrollo en el trabajo, y hora de mover los repositorios SVN a este nuevo servidor, para este caso instalaremos subversion en Manjaro 0.8.4, tan fácil como hacer desde una terminal:

$ sudo pacman -S subversion

Y tendremos instalado subversion!

Configuramos un directorio donde estarán nuestros repositorios:

$ mkdir /home/usuario/SVN

Muy bien, si quisiéramos iniciar el demonio de Subversion desde una terminal haríamos los siguiente:

$ svnserve -d -r /home/usuario/SVN

Con los parámetros -d indicamos que se inicie como demonio, y con -r indicamos el directorio raíz que alojará nuestros repositorios.
Pero en este caso queremos que subversion se inicie al bootear el sistema, para esto crearemos un archivo para iniciar el servicio, en SystemD que es el gestor de servicios de Archlinux y por lo tanto de Manjaro, creamos un archivo en la siguiente ruta:

$ sudo nano /etc/systemd/system/svn.service

Y agregamos las siguientes lineas:

[Unit]
Description=Subversion Service
After=network.target

[Service]
Type=forking
User=tuusuario
ExecStart=/usr/bin/svnserve -d -r /home/tuusuario/SVN

[Install]
WantedBy=multi-user.target

Aquí las lineas mas importantes son "After=network.target" para indicarle que sea iniciado después del servicio de red, "Type=forking" para iniciar el servicio como un demonio y permitir monitorear su estado a systemd, "User=tuusuario" para indicar con que cuenta de usuario será lanzado el servicio.

Guardamos los cambios y rehabilitamos el servicio y lo agregamos al inicio del sistema:

$ sudo systemctl reenable svn.service

Iniciamos el servicio:

$ sudo systemctl start svn.service

Y podemos revisar su estado:

$ systemctl status svn.service

Y si todo salió bien, nos deberá mostrar algo así:

svn.service - SVN Server
 Loaded: loaded (/etc/systemd/system/svn.service; enabled)
 Active: active (running) since vie 2013-03-01 07:32:14 MST; 1h 33min ago
Process: 310 ExecStart=/usr/bin/svnserve -d -r /home/tuusuario/SVN (code=exited, status=0/SUCCESS)
Main PID: 319 (svnserve)
 CGroup: name=systemd:/system/svn.service
 └─319 /usr/bin/svnserve -d -r /home/tuusuario/SVN

mar 01 07:32:10 manjaro systemd[1]: Starting SVN Server...
mar 01 07:32:14 manjaro systemd[1]: Started SVN Server.

Y listo!

Ahora leo que fedora cambió a SystemD, me da gusto ver que están tomando este gestor de servicios.

referencias:
Escribir los archivos .service personalizados (Wiki Arch)

Usando la API de twitter en JAVA

Este es un proyecto que comencé, era un cliente de escritorio sencillo de twitter, hecho en Java, lo comencé en Java pensando en la multiplataforma, estaba desempolvando Java y aprendiendo a usar swing para la interfaz gráfica, utilice una biblioteca llamada twitter4j para manejar la API de twitter.

Notese que el código esta algo desordenado, y hay bloques de código comentado, esto era por las pruebas, pero en funcionalidad, tenía los siguientes puntos:

• Te pide autorización para tu cuenta, y graba tu usuario y el token en una base de datos sqlite

• Permite mostrar la time line y las menciones

• Guarda tus followers en la base de datos con una fecha (la intención de esto era poder comparar que followers te dejaban de seguir)

• Detecta automáticamente los links y los acorta usando el servicio de bit.ly (también necesitaran registrarse en bit.ly para solicitar una llave y configurarla en el código)

Para hacer que funcione necesitaran registrarse en el sitio de desarrollo de twitter y pedir su token para crear una aplicación y en el código del programa configurar esta.

Las bibliotecas necesarias están en el directorio /dist/lib/

En el archivo comprimido viene la base de datos sqlite con las tablas que usa el programa.

Acá dejo el Link de descarga https://www.dropbox.com/s/1bwcslc5msgur9a/TweetJax.tar.gz

Nota debido a los recientes cambios en la API de twitter lo recomendable es que descarguen la ultima versión de la biblioteca twitter4j y la actualicen en el proyecto.

RabbitVCS integración con NEMO (Filemanager de Cinnamon)

Bueno, una herramienta que me gusta mucho para trabajar con repositorios SVN, es RabbitVCS.
RabbitVCS es una alternativa para TortoiseSVN para windows, tiene integración con los principales file managers como Nautilus, y Thunar.

Con la salida de la alternativa a Nautilus por parte de Cinnamon, NEMO, un muy buen file manager, que salva buenas características del antiguo Nautilus, y al ser un fork de este, se pueden portar algunas extensiones y características de Nautilus a Nemo. Sin embargo por parte de RabbitVCS todavía no hay un soporte oficial para Nemo, buscando en los foros de RabbitVCS encontré que se puede integrar a nemo, de una manera sencilla.

Lo primero es tener instalado RabbitVCS:

Si estamos en ubuntu añadimos su ppa:

$ sudo add-apt-repository ppa:rabbitvcs/ppa

e instalamos:

$ sudo apt-get update && install rabbitvcs

si estamos en Arch lo instalamos desde AUR:

$ yaourt -S rabbitvcs rabbitvcs-nautilus

con esto instalaremos Rabbitvcs y su soporte para nautilus.

Ahora mismo estoy leyendo que en el repositorio de AUR hay un paquete para dar soporte a nemo:

$ yaourt -S rabbitvcs-nemo

y con esto tendremos la integración en nemo.

para Ubuntu pueden descargar el siguiente archivo: http://rabbitvcs.googlecode.com/files/rabbitvcs-0.15.2.tar.bz2  descomprimirlo en la siguiente ruta:

"/usr/share/nemo-python/extensions"

y reinician nemo:

$ nemo -q; nemo

y listo! tendremos Rabbitvcs en nemo.

Buscando un DNS más rápido (Linux Manjaro [Archlinux] - Ubuntu)

Últimamente el DNS de mi proveedor de Internet falla o es demasiado lento al navegar, y recordé una utilidad que ayuda a buscar un DNS más rápido realizando diferentes tipos de pruebas, y al final te da un resultado con los DNS más rápidos.

Esta es una herramienta multiplataforma, pueden usarla en Linux, Mac Os y Windows.
La herramienta es Namebench

Para instalar en ubuntu, la pueden encontrar en los repositorios:

$ sudo apt-get install namebench

Y para Manjaro podemos encontrarlo en el repositorio de AUR

$ yaourt -S namebench

y si queremos usar la interfaz gráfica instalamos "tk", el paquete la muestra como dependencia opcional.

$ sudo pacman -S tk

Y listo lo podemos ejecutar desde la terminal y que haga su magia y si instalaron tk para la interfaz gráfica al ejecutarlo esta se mostrará y con un clic comenzará a trabajar. Pueden dejar los parámetros tal y como están al momento de ejecutarse, si son usuarios mas experimentados pueden modificar las opciones a su gusto.

 Aquí unas imágenes de namebench trabajando:

Resultados en terminal

Imagen de la interfaz gráfica de namebench

Una vez con los resultados, solo es cuestión de cambiar los DNS en la configuración de red, esto ya dependerá de nuestro sistema y escritorio que usemos (GNOME, KDE, LXDE, XFCE etc). 

Renombrando archivos con cierto patrón de nombre en LINUX (Bash)

Bueno, en Linux, desde la linea de comandos hay muchas formas de renombrar archivos de forma masiva, usando el comando "rename" o con "mv".

Esta forma que describiré hace uso de los comandos "find" "mv" "xargs".

El caso: queremos renombrar varios archivos en un directorio y todos son archivos .png, con diferentes nombres, y en sus nombres comparten cierto patrón, por ejemplo: "img_sony_newtrackfile.png" "img_sony_tablenew.png" "img_sony_newinserttext.png" ... entre otros con diferente patrón.

El caso es que no queremos renombrar todos los archivos png, solo queremos los que tengan el patrón "img_sony", bueno es fácil:

$ find . -iname '*img_sony*' | xargs -i -t mv {} mv {}_old

find . -iname '*img-sony*' - Este comando realiza una búsqueda de los archivos que en su nombre contengan "img_sony"

xargs -i -t mv {} mv {}_old - Este comando toma como entrada la salida del comando "find" a través del pipe | ,y archivo por archivo ejecuta el comando "mv" y renombra el archivo concatenando la cadena "_old" al final del archivo

Links: Encuentra cualquier cosa en Linux con find
Linux Command Directory: xargs

Instalación y configuración de SSH Server en Manjaro [ArchLinux]

Estos días sigo usando Manjaro Linux y me tiene muy contento, al estar basado en ArchLinux, la wiki de esta es muy grande y siempre saca de dudas, y si es algún asunto especifico de Manjaro, en su sitio y foro siempre encontrarás ayuda y contestan bastante rápido.

Bueno instalar un servidor SSH en Manjaro es igual que en Archlinux, y para ayuda podemos recurrir a la wiki donde esta bastante bien explicado, su instalación y configuración.

Solo voy a resumir algunos pasos de la instalación, ya que todo se puede encontrar en la wiki:

Instalamos desde la terminal:

$ sudo pacman -S openssh

o bien desde pacman-gui instalamos

Una vez instalado: desde la terminal nos movemos a:

$ cd /etc/ssh

Y ahí configuramos el archivo "sshd_config" que es el archivo de configuración del demonio de ssh, en la wiki podemos encontrar los parámetros óptimos, para su configuración, como es cambiar el puerto default, que es el 22, desactivar el login de root, entre otras cosas. Yo voy a mencionar algo que hay que activar para poder usar sftp en nuestro servidor SSH.

$ sudo nano sshd_config

Y buscamos la linea Subsystem sftp /usr/lib/ssh/sftp-server si esta comentada "#" las descomentamos y guardamos los cambios, OJO en mi caso, esta linea tenía otra ruta al binario del sftp-server Subsystem sftp /usr/lib/openssh/sftp-server y no existía esta ruta, solo hay que cambiar la ruta como la primera, quitando el "open".

Ahora iniciamos o reiniciamos el servicio, y como en Manjaro y un Archlinux actualizado ya se usa el systemd, usamos:

$ sudo systemctl restart sshd

Y si lo queremos agregar al inicio del sistema:

$ sudo systemctl enable sshd

Y listo, ya podemos conectarnos a nuestro servidor ssh y usar sftp para copiar o manejar nuestros archivos.

Probando Manjaro 0.8.2 - Archlinux

Manjaro Linux es una distribución basada en Archlinux, días atras estuve probando Archlinux haciendo una instalación en mi netbook, siguiendo la guía de instalación de la wiki de Arch no fue tan dificil, solo que si es bastante tardado. En mi opinión instalar Arch puro es bueno porque aprendes bastante y te permite ver como funciona todo desde "las entrañas" del sistema y te deja un sistema con justo lo que tu quieres. Pero para mi es poco practico tener que instalar todo desde cero.

 Y bueno hay otras distribuciones basadas en Arch que facilitan bastante esto, por ejemplo Archbang, Chakra, Cinnarch, que son las que personalmente he probado. Todas son buenas, tienen sus pros y contras.

Y no hace mucho tiempo descubrí Manjaro, una distribución basada en Arch, que ofrece una instalación con diferentes entornos de escritorio como XFCE, Cinnamon o Gnome Shell, y KDE, recién liberaron la versión 0.8.2 y decidí probarla, descargue la versión con Cinnamon e instale, todo trabajó "out of the box" me detectó todo el hardware sin problemas. 

El live CD viene con dos instaladores uno por consola y otro gráfico pero en estado "testing" instale con la versión CLI de coonsola, y todo es muy fácil, incluso viene la guía de instalación en el live CD. 

Una de las características mas interesantes para usuario novatos, son las aplicaciones que adaptaron para Instalar paquetes, Archlinux usa "pacman" para instalar paquetes, pacman en Arch es lo que apt-get a Ubuntu/Debian, y el "pacman-gui" si bien no es tan completo como un synaptic o el centro de software de ubuntu, permite una fácil instalación para los mas nuevos. Ademas de tener otra herramienta que es el "Pkgbrowser" para buscar paquetes en los repositorios. 

Instalando una aplicación con pacman-gui

Pkgbrowser - buscando paquetes en los repositorios.

Y bueno como en Arch, si no encuentras el paquete en los repositorios, siempre esta AUR, que ya viene configurado y listo para usarse son "yaourt" o "packer", desde la terminal lo podemos usar.

Este es mi escritorio de Manjaro con Cinnamon 1.6 + conky 

 

Build Authz 1.1.2 - Ayuda visual para construir el archivo "authz" [Actualizado]

Hoy liberé la nueva versión (1.1.2rv18) de esta herramienta que ayuda a construir el archivo "authz" para repositorios Subversion.  Referencia

En las novedades de la aplicación están:

• La opción de verificar el formato del archivo authz (mediante la herramienta de subversion "svnauthz-validate").
• Cargar usuarios desde un archivo "passwd".
• Guardar y cargar, la vista previa de los permisos que vamos configurando.

Y algunas correcciones de bugs.

pueden descargar los binarios para:

Windows

Linux

OsX

http://code.google.com/p/build-authz/downloads/list

Insync (Cliente Google Drive) - Sincronizando nuestros directorios en Ubuntu y Windows

Actualmente hay una gran variedad de servicios como Dropbox que nos ofrecen almacenamiento gratuito en la nube, ejemplo de esto lo tenemos en Ubuntu, con su servicio Ubuntu One que nos ofrece 5gb gratuitos, ademas de tener clientes multiplataforma, un servicio relativamente nuevo, es el liberado por Google, su servicio "Google drive". En lo personal, uso varios de estos servicios, entre ellos:

Ubuntu one
Google Drive
DropBox
Box

Google tardó un poco en liberar su API para este servicio (nada nuevo...), pero ya tenemos un cliente de escritorio para este servicio, y es Insync, es un cliente multiplataforma, entre sus características se integra con el administrador de archivos, y permite manejar cuentas múltiples.

Para instalarlo en Ubuntu/Mint, podemos agregar su ppa con los siguientes comandos: 

Para Ubuntu: 

$ echo "deb http://apt.insynchq.com/ubuntu $(lsb_release -cs) non-free" | sudo tee /etc/apt/sources.list.d/insync.list

Para Mint:

$ echo "deb http://apt.insynchq.com/mint $(lsb_release -cs) non-free" | sudo tee /etc/apt/sources.list.d/insync.list

Y después para cualquiera que sea, importamos las llaves:

$ wget -O - https://d2t3ff60b2tol4.cloudfront.net/services@insynchq.com.gpg.key | sudo apt-key add - sudo apt-get update

e instalamos:

Ubuntu (Soporte para Unity):

$ sudo apt-get install insync-beta-ubuntu

Mint (Soporte para Cinnamon):

$ sudo apt-get install insync-beta-cinnamon

Y con esto tendremos instalado este cliente para manejar nuestras cuentas de google drive, cuando lo ejecutemos nos pedirá ligarlo a alguna cuenta que tengamos de google, una vez hecho esto, en nuestro directorio HOME creará los directorios de nuestras diferentes cuentas y en estos tendremos los archivos y directorios que queramos sincronizar.

Para windows, solo hay que descargar el instalador y seguir las instrucciones.

A pesar de ser muy buen cliente, falta una que a mi parecer es una opción muy buena, y es la de elegir otros directorios para compartir y que estos no se encuentren dentro de los directorios que crea el cliente. Por ejemplo esta opción si la tiene Ubuntu One, permite seleccionar cualquier directorio de nuestro sistema y sincronizarlo con nuestra cuenta. 

Pues muy simple! Podemos crear enlaces simbólicos de archivos o directorios que queramos tener sincronizados.

Desde la terminal tecleamos: 

$ ln -s  /ruta/de/directorio/que/quieras-sincronizar  /home/tuusuario/Insync/tusuario@gmail.com/

Y listo, tendremos sincronizados los directorios o archivos, y simple! Ojo: si borramos los archivos desde nuestro directorio de Insync se borrarán de nuestro google drive pero no de nuestro pc.

[fix] Solución al problema de "GPG Badsig" al actualizar Ubuntu/Mint

Bueno, en lo personal, he tenido este problema muchas veces, cuando al estar actualizando se corta por alguna razón la red (algo habitual aquí en la oficina... ¬_¬)  y al momento de actualizar de nuevo, este error aparece "GPG badsig"

La solución es muy sencilla:
Movemos el directorio "lists" de "/var/lib/apt" a lists.old y actualizamos!

Pero! como es recurrente este problema en mi caso, tengo que borrar el directorio "lists" de "lists.old" cada vez que esto sucede, y es algo que se puede automatizar con un sencillo script.

#!/bin/bash
#Autor Max J. Rodriguez Beltran. 2012

user=$(whoami)
directorio="lists"
olddirectorio="lists.old"

if [ $user = "root" ]; then
    cd /var/lib/apt
    if [ -d $olddirectorio ]; then
        #echo "existe" $olddirectorio
        cd $olddirectorio
        if [ -d $directorio ]; then
            echo "borramos " $directorio "de " $olddirectorio
            rm -r $directorio
        fi 
        cd /var/lib/apt
        echo "movemos " $directorio "al dir: " $olddirectorio
        mv $directorio ${olddirectorio}/
        echo "ahora actualizamos la lista..."
        sleep 5;
        apt-get update
    fi
else
    echo "Ejecuta este script con sudo"
    exit 1
fi
echo "Termino ejecución"

pueden copiar y pegar el script, solo recuerden dar permisos de ejecución al script y ejecutarlo como root.

$chmod +x fixgpgbadsig.sh

y ejecutan:

$sudo ./fixgpgbadsig.sh

O pueden descargar el script y leerlo, ejecutarlo y modificarlo a su gusto.
Descarga: fixgpgkeyproblem.sh 

Build Authz 1.0 - Ayuda visual para construir el archivo "authz"

Este es el primer release de esta pequeña aplicación que nació para facilitar la configuración y creación del archivo "authz" para los repositorios de Subversion. Esta desarrollada en Lazarus 1.0.2.

Para recordar ver el post

SVN - Control de acceso con Authz

Esta aplicación es liberada bajo licencia GPL, es Software Libre y pueden descargar el código fuente desde el siguiente repositorio:

http://code.google.com/p/build-authz/

para modificarlo, leerlo y compilarlo a su gusto.

O pueden descargar los binarios precompilados para las diferentes plataformas:

• Windows
• Linux/Gtk
• OsX

http://code.google.com/p/build-authz/downloads/list

La documentación y manual se encuentra en la lista de descarga.

Llenando un Treeview desde un directorio en lazarus (Linux/Windows)

Bueno vengo a poner un ejemplo sencillo de como llenar un Treeview desde un directorio en Lazarus, algo curioso que note al portarlo a Linux y OsX es que el valor que la constante "faDirectory" en Windows toma un valor de "16" y en SO "Unix" toma el valor de "48" por ese detalle al principio no me listaba los directorios, después de ir viendo paso por paso los valores que tomaban me di cuenta de eso, solo agregamos una validación que identifique el SO en el que se esta ejecutando y ajustar ese valor.

En el ejemplo agregamos al evento OnClick de un botón el siguiente código:

procedure TfrmMain.btnAgregaMarcadorClick(Sender: TObject);
var
    lcSearch: TSearchRec;
    lcFileAttr: integer;
    lcFatherNode: TTreeNode;
    lcChildNode: TTreeNode;
    lcPath: String;
begin
    {$IFDEF UNIX}
        lcFileAttr:= 48;
    {$ELSE}
        lcFileAttr:= faDirectory;
    {$ENDIF}
    SelectDirectoryDialog1.Execute;
    lcPath:=SelectDirectoryDialog1.FileName;
    if Length(lcPath) > 0 then begin
        lcFatherNode:= TTreeNode.Create(TreeView1.Items);
        lcFatherNode:= TreeView1.Items.AddChild(TreeNodeRoot,lcPath);
        lcFatherNode.ImageIndex:=0;
        lcFatherNode.SelectedIndex:=0;
        lcFatherNode.Expanded:=True;
    end;
    lcPath:=lcPath+PathDelim;
    If FindFirst(lcPath+'*',faDirectory,lcSearch)=0 then begin
        repeat
            if lcSearch.Attr = lcFileAttr then begin
                if (lcSearch.Name = '.') or (lcSearch.Name = '..') then continue;
                lcChildNode:= TreeView1.Items.AddChild(lcFatherNode,lcSearch.Name);
                lcChildNode.ImageIndex:=0;
                lcChildNode.SelectedIndex:=0;
                AddDirectorios(lcChildNode,lcPath+lcSearch.Name);
            end;
        until FindNext(lcSearch) <> 0;
        FindClose(lcSearch);
    end;
   TreeView1.Refresh;
end;

El siguiente procedimiento lo agregamos nosotros, este será llamado desde nuestro anterior proceso cuando encuentre un directorio, y será llamado recursivamente desde él mismo agregando los nodos hijos con el nombre de los directorios encontrados.

procedure TfrmMain.AddDirectorios(elNodo: TTreeNode; cPath: String);
var
    sr: TSearchRec;
    lcFileAttr: Integer;
    theNewNode : tTreeNode;
begin
    {$IFDEF UNIX}
        lcFileAttr:= 48;
    {$ELSE}
        lcFileAttr:= faDirectory;
    {$ENDIF}

    if FindFirst(cPath+PathDelim+'*', faDirectory, sr) = 0 then begin
        repeat
            if sr.Attr = lcFileAttr then begin
                if (sr.Name = '.') or (sr.Name = '..') then continue;
                    theNewNode := TreeView1.Items.AddChild(elNodo,sr.name);
                    theNewNode.ImageIndex:=0;
                    theNewNode.SelectedIndex:=0;
                    AddDirectorios(theNewNode,cPath+PathDelim+sr.Name);
            end;
        until FindNext(sr) <> 0;
        FindClose(sr);
    end;
end;

Ejemplo sencillo usando Hilos (Threads) con Lazarus 1.0 en Linux (Ubuntu12.04)

Bueno, buscando mejorar el rendimiento de una aplicación que estoy desarrollando *mientras aprendo* usando el IDE Lazarus, supuse que lo mejor sería usar hilos para ciertos procesos de la aplicación que pueden llegar a ser pesados, al ver y probar algunos ejemplos de multithreading en windows vi que era la solución, todo bien, estuve probando y experimentando y funcionaba de lo lindo en windows, al compilarlo en Linux, todo compilaba bien... solo que al llegar a crear el hilo saltaba una excepción fatal!

Revisando el código, probando linea por linea, comparándolo con el ejemplo de multi threading que viene con Lazarus, no encontraba el error, usaba lo que tenía que usar, todo en su lugar... eso creía yo.

Esto es una sugerencia basada en mi experiencia: Si preguntan en algún foro, y esperan una respuesta rápida, pregunten en foros en idioma Inglés, cuando he preguntado en foros en español, o no me contestan, o tardan millones de años.

Bueno lancé la pregunta en el foro de Lazarus y en Stack Overflow, minutos mas tarde ya me estaban respondiendo con algunos tips, y comentarios de lo que podría estar fallando o faltando en mi proyecto.

En resumen la cuestión era que si se van a usar threads en Linux(UNIX, OsX  BSD y demás) es necesario agregar al archivo ".lpr" del proyecto (este archivo es creado automaticamente al crear un proyecto, en el directorio del proyecto) necesitamos agregar la siguiente linea:

{$define UseCThreads}

Quedando de la siguiente forma el documento:

{$mode objfpc}{$H+}
{$define UseCThreads}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, Unit1
  { you can add units after this };
  .
  .
  .

Una vez agregado esto y recompilando, funcionó.

Bueno voy a agregar el pequeño ejemplo:

Comienzan un nuevo proyecto en Lazarus->aplicación, y agregara un form vacío, agregamos un botón y un progressbar para el ejemplo.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ComCtrls;

//Creamos el type para lo que será nuestro hilo
type

{ TMiHilo }

  TMiHilo = class(TThread)
  private
    procedure AvanzaBarra;
  protected
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: boolean);
  end;     

{ TForm1 }
  TForm1 = class(TForm)
    Button1: TButton;
    ProgressBar1: TProgressBar;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;         

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }
//agregamos al evento click del botón, aquí se iniciará nuestro hilo al dar click
procedure TForm1.Button1Click(Sender: TObject);
var
    MiHilo : TMiHilo;
    begin
        //creamos el hilo, pero no lo iniciamos
        MiHilo := TMiHilo.Create(True); // Con el parametro true no se inicia automaticamente
        if Assigned(MiHilo.FatalException) then
           raise MiHilo.FatalException;
        //si no hay ninguna excepción lo iniciamos
        MiHilo.Start;
end;

//aquí definimos los procesos para el hilo
{ TMiHilo }

procedure TMiHilo.AvanzaBarra;
//Este metodo solo es llamado por Synchronize(@AvanzaBarra) y por ello
// es ejecutado por el hilo principal.
//El hilo principal puede acceder a los elementos visuales del GUI por ejemplo a la progressbar 
begin
    Form1.ProgressBar1.StepIt;

    if Form1.ProgressBar1.Position = Form1.ProgressBar1.Max then begin
        Form1.ProgressBar1.Position := 0;
    end;
end;

//Este proceso se ejecuta al iniciar el hilo
procedure TMiHilo.Execute;
begin
    
    //mientras no termine y sea verdadero se ejecutará 
    while (not Terminated) and (true) do begin
        //este loop es del hilo principal 
        Synchronize(@AvanzaBarra);
    end;
end;

constructor TMiHilo.Create(CreateSuspended: boolean);
begin
    //Con esta propieda del hilo no necesitamos liberarlo manualmente al terminar de ejecutar el hilo
    FreeOnTerminate := True;
    inherited Create(CreateSuspended);
end;


end.

Y listo, compilamos y ejecutamos y debemos ver nuestro formulario con un botón y una barra de progreso, al dar clic en el botón esta comenzará a llenarse, cuando se llene se vaciará y comenzara de nuevo. No olviden agregar la linea {$define UseCThreads} en el archivo .lpr de su proyecto para que la validación de "si es compilado en Unix" use cThreads.

Mi escritorio de Octubre

Bueno, aprovechando que cambie mi escritorio de gnome classic a Cinnamon, les comparto un screenshot de mi escritorio.

Tema cinnamon: Zukitwo-Human
Tema Gtk3: Ambiance-Orange
Iconos: Faenza
Dock:Cairo dock
Wallpaper: Wallpaper
Conky

Icono para menu cinnamon: Start-here-hl.png 24x24

Desarrollo multiplataforma con Lazarus (Clon de Delphi)

¿Que es Lazarus?

Bueno en su página podemos encontrar lo siguiente:

Lazarus es el conjunto de bibliotecas de clases para el compilador Free Pascal que emula a Delphi. Free Pascal es un compilador de licencia GPL que trabaja sobre Linux, Windows, OsX, OS/2, 68k y más.

Lo interesante de esto es que podemos crear nuestro proyecto en cualquier plataforma y solo tendremos que compilarla en otras para mudarla. Como ejemplo, creamos un proyecto en Windows con componentes normales de este, para migrarlo a Linux solo tenemos que mover el proyecto al equipo con Linux y Lazarus instalado, seleccionar que conjunto de widgets queremos utilizar (GTK o Qt para Linux) y compilarlo, Lazarus se encargará de todo, no tenemos que reescribir nuestro código.

A diferencia de Java que es "compilalo una vez ejecútalo donde sea", con Lazarus lo escribimos una vez y lo compilamos donde queramos".

En cuanto al lenguaje, como se menciono es un clon de Delphi, entonces para los que usaron esta herramienta, será muy familiar para ellos.

A finales del mes pasado (Agosto) acaban de liberar la versión 1.0 de esta herramienta.

Podemos ver las notas de cambios aqui:  http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes 

Acá unas imágenes de como se ve trabajando en Linux 

Y acá imágenes del mismo proyecto compilado en Windows:

La herramienta esta muy completa, se encarga de hacer los bindings para la interfaz, tiene soporte nativo para bases de datos, MySQL, PostgreSQL, SQL Sever y más, y es multiplataforma, así que vale la pena probarlo. 

Para Ubuntu/Mint no esta en los repositorios oficiales y desafortunadamente no cuenta con un ppa, pero en la página de descargas ofrecen los paquetes DEB con los que podemos instalarlos fácilmente.

Sitio de descarga: http://sourceforge.net/projects/lazarus/files/

Sitio principal de Lazarus: http://www.lazarus.freepascal.org/

SVN - Control de acceso con Authz

Actualmente utilizamos en la empresa SVN como sistema de control de versiones para nuestros proyectos, es práctico y nos ha servido bastante bien, hasta ahora hemos utilizado el método del archivo "passwd" para dar acceso a los repositorios de los proyectos, no habíamos necesitado de nada más.

Actualmente ha surgido la necesidad de buscar una manera de crear un repositorio común para toda la organización pero con acceso limitado por carpetas para los diferentes usuarios.
Leyendo un poco acerca de las diferentes formas de control de acceso para SVN encontré que usando  svnserve, y configurando el archivo "authz" se puede configurar el acceso a directorios, en base a usuario o grupos de usuarios.

En este caso lo mejor es crear el árbol de directorios que se usará para que en base a ese árbol configuremos el archivo "authz", aunque siempre se puede modificar si se agregan mas directorios y se quiere mantener el acceso restringido a estos.

NOTA es importante definir bien la estructura del directorio, desde los niveles mas bajos a los mas altos.

Primero creamos un repositorio, lo llamaremos "Proyectos", editamos el archivo svnserve.conf que se crea, buscamos y descomentamos las siguientes lineas:


#    anon-access = read #    auth-access = write .
.
.
#   password-db = passwd

para que queden sin la almoadilla "#"

anon-access = read

auth-access = write
.
.
.
password-db = passwd

Y añadimos los usuarios que vayan a utilizar el repositorio en el archivo "passwd"

para este ejemplo agregaré 4 usuarios:

[users]
admin = adminssecret
devchief = chiefssecret
developer1 = devs1secret
developer2 = devs2secret
developer3 = devs3secret

Después creamos la estructura de directorios:

Voy a poner un ejemplo simple de estructura de directorios:

Directorio Raiz: --Proyectos
                              --Web
                                 --PERL
                                 --PHP
                                 --RUBY

importamos a nuestro repositorio el directorio raiz con los subdirectorios:
ya sea que lo hagan con un cliente gráfico como VCSRabbit o Tortoise
o desde la terminal, que sería así:

$ svn import -m "estructura" --username admin --password adminssecret Proyectos/  svn://tuserver/Proyectos 

Así queda creada la estructura de directorios base en el repositorio.

Ahora si! es hora de configurar el archivo "authz"
Abrimos el archivo authz que se encuentra en el directorio de nuestro repositorio y buscamos la sección [groups] que es donde configuraremos los grupos con los usuarios que definimos en el archivo "passwd"

deberá quedar algo así:


[groups]
Admins = admin, devchief
Developersphp = developer1, developer3
Developersperl = developer2
Developersruby = developer2, developer3

después de esta sección vamos a configurar el acceso a los directorios de la siguiente manera:

primero tenemos que dar acceso a todos los usuario a la raíz del repositorio, pero solo daremos permiso de escritura al grupo de administradores. No se le puede otorgar un permiso de escritura a un usuario/grupo si no tiene acceso de lectura al directorio padre.

[/]
@Admins = rw   #con esto damos acceso de lectura y escritura a el grupo Admins
* = r    #con esto damos acceso a todos acceso de lectura

[/Web] #Ahora configuramos los accesos para el siguiente nivel, que es el directorio "Web"
* = r    #con esto damos acceso a todos acceso de lectura
@Admins = rw   #con esto damos acceso de lectura y escritura a el grupo Admins

[/Web/PHP]  #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "PHP"
@Developersphp = rw   #con esto damos acceso de lectura y escritura a el grupo Developersphp, entonces SOLO el usuario developer1, developer3 podrán ver y escribir este directorio
@Admins = rw #con esto damos acceso de lectura y escritura a el grupo Admins
* =   #Con esto se asegura que nadie mas tenga ningún tipo de acceso al directorio

[/Web/PERL] #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "PERL"
@Developersperl = rw #con esto damos acceso de lectura y escritura a el grupo Developersperl, entonces SOLO el usuario developer2 podrá ver y escribir este directorio
@Admins = rw
* =


[/Web/RUBY] #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "RUBY"
@Developersruby = rw #con esto damos acceso de lectura y escritura a el grupo Developersruby, entonces SOLO los usuarios developer2 y developer3 podrán ver y escribir este directorio
@Admins = rw
* =


 #Nota si se desea puede darse acceso a usuarios por separado de a siguiente forma:
#[/Web/PERL] 
#developer2 = rw
#devchief  = r
#* =

Guardamos y cerramos el archivo.
Ahora hay que descomentar una linea más en el archivo "svnserve.conf"
Buscamos la siguiente linea:

# authz-db = authz

lo descomentamos y lo dejamos así:


authz-db = authz

Guardamos y cerramos el archivo, y reiniciamos el demonio o servicio de svnserve.

Ahora cuando el usuario "admin" haga un checkout del repositorio podrá ver y escribir en todos los directorios. Y cuando el usuario developer1 solo podrá ver y escribir en el directorio "PHP" y así para cada uno de los diferentes usuarios que configuramos en el archivo authz.

Lighttpd + PHP en Windos parte 2 + Dokuwiki

Continuando con el tema de Lighttpd + PHP en Windows, veremos como instalar y configurar PHP para lighttpd.

Primero descargamos PHP desde su sitio http://windows.php.net/download/ yo descargue la ultima versión al momento PHP 5.4 (5.4.6), descargue el .zip.

Una vez descargado, lo descomprimo en el directorio de Lighttpd y creo un directorio "PHP", en mi caso C:\Lighttpd\PHP

Una vez hecho esto, buscamos en el directorio php el archivo "php.ini-development" lo renombramos a "php.ini" lo abrimos y buscamos la siguiente linea:

;cgi.fix_pathinfo=1

Y descomentamos la linea, borrando el punto y coma del inicio.

 cgi.fix_pathinfo=1

Guardamos y cerramos el archivo.

Ahora en el archivo "lighttpd.conf" en el directorio "conf" lo editamos y buscamos la siguiente linea y descomentamos
#### fastcgi module
.
.
.
#fastcgi.server             = ( ".php" =>
#                              ( "localhost" =>
#                                 (
#                                  "host" => "127.0.0.1",
#                                   "port" => 9000
#                                 )
#                               )
#                             )

para dejarlo de la siguiente forma:


fastcgi.server             = ( ".php" =>
                              ( "localhost" =>
                                 (
                                  "host" => "127.0.0.1",
                                   "port" => 521
                                 )
                               )
                             )

y guardamos y cerramos el archivo.

Ahora necesitamos ejecutar "Lighttpd" y "php-cgi"
Para esto podemos hacer un script que inicie ambos ejecutables:

@ECHO OFF
START /B PHP/php-cgi.exe -b 127.0.0.1:521
ECHO LightTPD
ECHO.
ECHO Presiona 'INTRO' para salir.
ECHO.
ECHO LightTPD:
ECHO ---------
START /B lighttpd.exe -f conf/lighttpd.conf -m modules -D
PAUSE > NUL
TASKKILL /F /IM php-cgi.exe
TASKKILL /F /IM lighttpd.exe
EXIT

Lo guardamos con extensión ".BAT" y lo ejecutamos.

Entramos desde el navegador a: http://localhost:81/index.php

y nos deberá mostrar la página de información de PHP. Podemos agregar para que se ejecute al inicio el script que inicia Lighttpd y PHP.

Una vez hecho esto solo tenemos que descargar "DokuWiki" desde su sitio http://www.splitbrain.org/projects/dokuwiki

Descomprimimos el archivo en el directorio "htdocs" de Lighttpd, en mi caso renombre solo por "dokuwiki" el directorio y desde el navegador entramos a:

http://localhost:81/dokuwiki/install.php

y seguimos las instrucciones de configuración para nuestra wiki.