25 dic. 2011

Pimp Firefox

Como ya comente me regrese al firefox, pero esto tiene algunas implicaciones y es que se requieren algunas extensiones para que funcione, con algunas características que ya me gustaban de Chrome.

Lo primero sera la apariencia, admito que me gusta mucho más la de Chrome que la de Firefox.

Así que lo primero sera instalar FxChrome que es una extensión que le da la apariencia visual de Chrome a Firefox. Como se ve en la imagen.




Hay otra cosa que me encanta de Google Chrome y es la posibilidad de abrir archivos PDF dentro del mismo navegador. En el caso de Chrome esto se hace usando Flash para cargar un visor de PDF. En Mozilla también tienen su extensión pero a diferencia de la de Chrome esta usa HTML5.


Otra opción que me encanta tener en Firefox es el sistema de Marcadores de Chrome ya que la barra de marcadores de Firefox es estática y no se puede quitar con facilidad. Esta extensión tiene un comportamiento más interesante incluso que el de Chrome, la barra de marcadores solo aparece en pestañas nuevas y una vez carga la pagina desaparece.


La barra de descargas de Chrome es algo que sin duda le hace mucha falta a Firefox, de hecho no me gusta mucho que el programa me pregunte que hacer con las descargas así que lo tengo configurado para que todo el contenido se descargue en automático.



No puede faltar el Addblock Plus aunque esto no existe en Chrome por defecto pero a mi me gusta demasiado porque quita toda la publicidad de los sitios que visito.


Y finalmente una que no esta por defecto tampoco en Chrome pero en Firefox me gusta mas su funcionamiento y me permite descargar los videos o musica de Youtube.


Con estas extensiones y otras que hay disponible para Firefox el navegador sin duda alguna no puede pasar desapercibido como uno de los mejores que hay en la web.

De Regreso a Firefox

Después de usar Google Chrome durante mucho tiempo he vuelto al confiable y siempre seguro Firefox. Muchos pensaran que es algo extraño teniendo en cuenta las tendencias actuales en la que la mayor parte de las personas se pasan de Firefox a Chrome. A mi basicamente me vienen dos simples razones a la cabeza.

La primera tiene que ver con el consumo de memoria de Ram que ultimamente en Chrome esta en unos limites desesperantes.
Como se puede ver en la imagen tengo abierto en la parte superior el Chrome y en la parte inferior el Firefox y al comparar el consumo de memoria RAM. Podemos notar que el Firefox esta por los lados de 141 Mb, al sumar los procesos de Chrome nos podemos dar cuenta que esta por los lados de 181 MB


Firefox 8 = 141 MB
Chrome 16 = 181 MB

El numero de extensiones podria afectar ese dato de consumo de RAM pero para esta prueba he dejado las extensiones como las tengo sin deshabilitar ninguna.

Firefox 8 = 10 Extensiones
Chrome 16 = 5 Extensiones

La segunda razón por la que me paso a Firefox es debido a que recientemente he instalado en mi pc un monitor de consumo de energía que detalla el consumo en Watts por cada programa.

Al realizar un análisis estadístico y graficar los datos me lleve la sorpresa de que cuando uso Chrome la batería de mi laptop demora 25 minutos menos que cuando uso Firefox. Esto teniendo en cuenta que uso una extensión DIM en Chrome para reducir su consumo de energía desde hace ya más de 5 meses. De hecho en la imagen se puede ver que esta en ON.

Estas dos razones me han llevado a cambiar mis hábitos y adaptarme a Firefox, en mi próximo post contare que he modificado para que funcione y se vea similar a Chrome, ya que es imposible negar que Chrome es uno de los mejores navegadores que hay en la red hoy en día.

13 dic. 2011

Consumo Energia Ubuntu 11.10 y 12.04

Para los interesados en realizar test para mejorar el consumo de energia en sus laptops Ubuntu ha creado una Wiki que busca personas que esten dispuestas a realizar test para mejorar el consumo de energía.

Les dejo los dos enlaces y espero que puedan aportar para mejorar esta distro.

Aggressive Link Power Management

Updates to pm-utils power.d scripts

Python y D-Bus

Esta pequeña entrada la tenia pendiente desde hace mucho tiempo, para los que quieran comenzar a ver lo que ofrece D-Bus.

Lo primero es crear un servicio dbus.


import dbus
import dbus.service
from dbus.mainloop.glib import DBusGMainLoop

Estas tres primeras lineas lo que hacen es primero import dbus después importar los servicios que ofrece dbus y finalmente crear un glib loop que es básicamente un ciclo continuo para que busque eventos de Dbus.
class MyDBUSService(dbus.service.Object): def __init__(self): bus_name = dbus.service.BusName('org.primerdbus.serviciohola', bus=dbus.SessionBus()) dbus.service.Object.__init__(self, bus_name, '/org/primerdbus/serviciohola') @dbus.service.method('org.primerdbus.serviciohola') def hello(self): return "Hello,World!" @dbus.service.method('org.primerdbus.serviciohola') def shutdown(self): loop.quit() DBusGMainLoop(set_as_default=True) myservice = MyDBUSService() loop = GObject.MainLoop() loop.run()

Estas 3 primeras lineas suelen ser siempre las mismas para cualquier servicio que estemos pensando crear.
Voy a pegar el codigo del servicio y explicare las lineas.

Para crear un servicio lo primero es crear una clase en este caso la clase se llama MyDBUSService esta clase tiene 3 objetos. dbus service y object.

Lo primero sera crear el nombre del bus con el comando de la linea 3 el nombre que se le asigna para este caso es org.primerdbus.serviciohola.

Tenemos que inicializar ahora un objeto que en este caso es bastante evidente, vamos a inicializar el recién creado servicio llamado servicehola llamándolo desde org/primerdbus/serviciohola.

Este recién creado e inicializado servicio debe también debe ofrecer algo, porque esa es la esencia de un servicio ofrecer opciones o características que nos sean interesantes a este tipo de cosas que ofrecen los servicios los llamamos métodos.

En este caso particular de nuestra primera aproximación se van a crear dos métodos, uno que hace algo para nosotros y otro que cierra y termina el servicio y que es de alguna forma estándar y debe estar presente en todos los servicios que creemos de aquí en adelante.
Las lineas 13, 14 y 15 terminan y cierran el servicio y siempre las tenemos que poner en cualquiera que creemos.

13 @dbus.service.method('org.primerdbus.serviciohola'
14 def apagar(self): 
15 loop.quit()


Las lineas 9, 10 y 11 crean una definición que se llama hola y es propia (self) y lo único que hace es retornarle a self un texto que en este caso es Hola Mundo!. Si ya se que es un ejemplo muy tonto pero es básico para iniciarse.

9 @dbus.service.method('org.primerdbus.serviciohola'
10 def hola(self): 
11 return "Hola Mundo!"

Finalmente las ultimas lineas cierra el bucle y con esto hemos terminado de crear un servicio. Por cierto el bucle lo he creado con GObject pero lo pueden crear con Gtk. Creo que es mejor usar GObject porque da menos pataletas para los servicios.

Ahora la pregunta es como consumir un servicio. Para eso creamos algun nuevo archivo en python que se encargara de llamar al servicio y consumirlo.

1 import dbus  
2  
3 bus = dbus.SessionBus()  
4 serviciohola = bus.get_object('org.primerdbus.serviciohola',  
5 '/org/primerdbus/serviciohola')  
6 metodohola = serviciohola.get_dbus_method('hola',  
7 'org.primerdbus.serviciohola')  
8 print (hola())  
9 
10 metodoapagado = serviciohola.get_dbus_method('apagar',
11 'org.primerdbus.serviciohola')
12 
13 apagar()

La linea 4 llama al servicio usando el nombre y la ruta.

El comando get_dbus_method se encarga de buscar los métodos con los nombres que tenga dentro del servicio en este caso creamos dos métodos hola y el siempre y clásico apagar.

El método hola se ejecuta con la instrucción print (hola()) que como ya saben dentro de hola esta self que guardo Hola Mundo!.

El segundo metodo es apagar() que lo que hace es enviar el comando loop.quit() y termina el servicio.


Espero que esta primera entrada les ayude a entender un poco Dbus.

10 dic. 2011

Tutorial para Crear un DEB y subirlo a tu PPA

Si estas mirando esta entrada puede ser interesante que visites este tutorial anterior.

Este tutorial nos va a a enseñar a hacer lo siguiente de forma fácil:

1. Crear un proyecto sencillo en Python con novedades de Python3 + PyGObject + GtkBuilder + GTK3.
2. Crear un paquete .deb de 32bits o 64bits para nuestro proyecto en python
3. Subir un archivo fuente .tar.gz (changes) a nuestro repositorio en launchpad (PPA)

Vamos entonces a crear un PROYECTO bastante simple en python para crear un deb a partir de este y después crear un source y subirlo a nuestro PPA.

Como yo estoy arrancando un proyecto personal vamos a usar mi proyecto como referencia, ustedes lo pueden aplicar a cualquier proyecto o programa que tengan.

Lo primero sera crear el archivo de GtkBuilder usando la tecnología de GTK3 para ello simplemente abrimos Glade y creamos algo parecido a lo que les muestro en la siguientes imágenes.

Crean una ventana, agregan una barra de herramientas y agregan dos botones uno al que he nombrado Conectar y el otro Actualizar. Este programa que estoy creando en python permite conectar nuestro PC a nuestro Televisor usando DLNA por medio del demonio minidlna, es un programa bastante simple en esta versión que les muestro.


Recuerden poner la ventana Main Visible


En la pestaña Señales de la ventana principal Main agregan lo que ven en esta imagen para garantizar que el programa si cierre


Le damos una señal al boton conectar.


Le damos una señal al boton actualizar.



Con eso hemos terminado la parte gráfica del programa. Se que lo he explicado algo rápido pero si quieren aprender acerca de GtkBuilder es mejor que revisen mis tutoriales y los lean con calma.

Guardamos el archivo como GeoDLNA.ui y ya terminamos la parte grafica de GTK3

Ahora vamos a crear un archivo en Python.

import sys import os from gi.repository import Gtk login = os.getenv("HOME") class main: if os.path.exists(login+"/.minidlna/cache") == False: os.system("mkdir -p ~/.minidlna/cache") if os.path.isfile("/etc/minidlna.conf") == True: os.system("cp /etc/minidlna.conf ~/.minidlna") else: print ("Please install minidlna with apt-get install minidlna") def __init__(self): builder = Gtk.Builder() builder.add_from_file("/usr/share/geodlna/data/gui/GeoDLNA.ui") self.window = builder.get_object("Main") self.bconectar = builder.get_object("Conectar") self.bactualizar = builder.get_object("Actualizar") dict = {"on_Main_delete_event": self.quit, "on_conection_clicked": self.connect, "on_Reloaded_clicked":self.reloaded, } builder.connect_signals(dict) #Definicion del comando iniciar el servidor miniDLNA def connect(self, widget): if self.bconectar.get_stock_id() == "gtk-disconnect": os.system("minidlna -f"+login+"/.minidlna/minidlna.conf -P"+login+"/.minidlna/minidlna.pid") self.bconectar.set_stock_id("gtk-connect") self.bactualizar.set_sensitive(False) else: self.bconectar.set_stock_id("gtk-disconnect") self.bactualizar.set_sensitive(True) os.system("pkill minidlna") #Definicion de actualizar el servidor miniDLNA def reloaded(self,widget): os.system("minidlna -f"+login+"/.minidlna/minidlna.conf -R") self.bactualizar.set_sensitive(False) self.bconectar.set_stock_id("gtk-connect") def quit(self,*args): os.system("pkill minidlna") Gtk.main_quit() #Ejecucion del programa if __name__ == "__main__": main() Gtk.main()


Voy a explicar solo algunas cosas.

Importamos GTK3 usando from gi.repository

Login lo que hace es obtener la ruta hacia el directorio /home/user usando una funcion llamada os.getenv

os.path.exists es una función que permite determinar si una ruta a un archivo existe, en caso de que no exista os.system es como usar la terminal dentro de python y le damos crear una carpeta en nuestra /home con el nombre .minidlna.

os.path.isfile es la forma mas segura que conozco para verificar que un archivo existe, si es verdad entonces os.system que es como correr la terminal dentro de python lo copia de un punto y lo mete dentro de la carpeta que creamos hace poco.
Como pueden ver print ahora tiene () y eso se debe a que así funciona print en Python 3.

Definimos el constructor con la ventana y los botones y lo que necesitamos para el programa dentro de la funcion __init__

La función get_stock_id() lo que hace es determinar el nombre del icono del boton en este caso es desconectar.

La función set_stock_id() cambia el icono del botón en este caso por el del icono conectado.

La función set_sensitive(False) hace que un boton quede invalidado y evita que sea pulsable. En este programa en particular si el servidor DLNA esta conectado este no se puede actualizar.

Con eso he terminado de explicar las generalidades del programa en python, si las quieren en detallado me dejan algún comentario y les respondo lo que pregunten.
Guardamos lo anterior como geodlna.py



NOTA: SI EL PROGRAMA NO SE EJECUTA ES DEBIDO A LA LINEA 19 QUE FUE MODIFICADA PARA EL PASO DE CONSTRUIR EL .DEB, SI DESEA VER EL PROGRAMA EN FUNCIONAMIENTO CÁMBIELA POR LO SIGUIENTE:
builder.add_from_file("GeoDLNA.ui") 
RECUERDE ADICIONALMENTE QUE GeoDLNA.ui DEBE ESTAR EN LA MISMA CARPETA QUE geodlna.py


Ahora vamos a crear el proyecto, ya tenemos dos elementos, un archivo .ui y un archivo .py. Pero tenemos que crear algunas carpetas y una jerarquía de la misma.

Yo siempre hago lo siguiente.
Creo una carpeta llamada Proyecto, la pueden crear en cualquier lado puede ser el escritorio o donde quieran.
Dentro de la carpeta Proyecto creo una con el nombre del programa en este caso y usando las reglas de Debian tendríamos que nombrar la carpeta como geodlna-0.1, siempre se nombran así. Nombre de la carpeta-versión, en minúsculas.

Dentro de esta carpeta creamos una nueva carpeta que yo le pongo como nombre data y dentro de esta creo dos más a una la nombro media y a la otra la nombro gui.
Gráficamente la jerarquía queda de la siguiente forma.

Ahora es solo cuestión de llenar las carpetas.
En la carpeta geodlna-0.1 metemos el archivo de python geodlna.py
En la carpeta data no metemos nada
En la carpeta gui metemos el archivo creado en glade GeoDLNA.py
En la carpeta media metemos un icono para nuestro programa GeoDLNA.png

Falta un único archivo que tenemos que crear y ese el que permite abrir la aplicación cuando damos doble click.
Abrimos un documento de texto simple y pegamos lo siguiente, que crea ejecutables para nuestros programas en python. Lo voy a explicar pero solo un poco.


[Desktop Entry]
Version=0.1
Encoding=UTF-8
Name=GeoDLNA
GenericName=Controlador DLNA
Comment=Permite controlar el demonio minidlna
Exec=python /usr/geodlna/geodlna.py
Terminal=false
Type=Application
Categories=Gnome;Internet;
Icon=/usr/share/geodlna/data/media/GeoDLNA.png
StartupNotify=false


Version queda claro que indica la version en la que se encuentra el programa, Name indica el nombre del programa, nombre genérico es lo que hace el programa.

Exce es la linea que se encarga de buscar y ejecutar el programa, como ven esta apuntando a /usr/geodlna porque ahí es donde quedara el programa cuando tengamos listo el .DEB
Icon también apunta a donde quedara guardado el icono cuando tengamos listo el .DEB

Este archivo lo guardamos en la carpeta geodlna-0.1 con el nombre GeoDLNA.desktop

Ahora si, manos a la obra. Vamos a crear un archivo comprimido con el nombre geodlna_0.1.orig
Miren que cambiamos la geodolna- por geodlna_ y agregamos .orig


Este cambio de nombre es porque así lo maneja y lo entiende dh_make de Debian.

Listo ya tenemos las piezas listas, ahora vamos a abrir el terminal, no se asusten que realmente es bastante fácil de hacer.

sudo apt-get install dh-make

Eso lo hacemos para tener la herramienta que construye archivos Debianizados.
Ahora nos vamos desde la terminal hasta dentro de la carpeta geodlna-0.1 usando el comando cd
En mi caso es algo más o menos así.

cd /home/geojorg/Escritorio/Proyecto/geodlna-0.1

Ahora dentro de la carpeta vamos a ejecutar el siguiente comando.

dh_make -e geojorg@gmail.com     RECUERDEN PONER SU CORREO, EL MISMO DE LA FIRMA DIGITAL
Cuando el programa se ejecuta nos preguntara si queremos crear un binario singular, un binario indep, multiples binarios, libreria, modulo del kernel o patch para el kernel.

Nuestra respuesta es s (binario singular)


Le damos enter y hemos terminado de debianizar nuestro programa.

dh_make tiene muchas opciones muy completas pero como estamos haciendo nuestra primera aproximación al programa la verdad no quiero explicar cosas complejas pero no por menos muy interesantes.

MINI NOTA: NO CIERREN LA TERMINAL

Si volvemos a ver las carpetas dentro del programa vemos que se ha creado una nueva que dice Debian. Esta carpeta contiene archivos para crear el empaquetamiento .DEB

La abrimos y vamos a borrar todos los archivos que terminen en .ex porque todo el mundo siempre dice que hay que borrarlos y la verdad yo aun no se realmente cual es la funcionalidad de esos archivos, si alguien sabe que me deje el comentario.

Nos deben quedar entonces los siguientes archivos dentro de la carpeta Debian.

Vamos a revisarlos y a modificarlos para que cumplan una buena misión.

CHANGELOG
(EN ROJO LO MÁS INTERESANTE Y RELEVANTE EN EL CAMBIO)

geodlna (0.1-1) oneiric; urgency=low

  * Lanzamiento version 0.1
    -Interfaz GTK3 para Minidlna

 -- Jorge Guerrero  Fri, 09 Dec 2011 22:00:48 -0500


CONTROL
(EN ROJO LO MÁS INTERESANTE Y RELEVANTE EN EL CAMBIO)

Source: geodlna
Section: python
Priority: extra
Maintainer: Jorge Guerrero
Build-Depends: debhelper (>= 8.0.0), python (>= 2.7), minidlna
Standards-Version: 3.9.2
Homepage: <http://geowworld.blogspot.com>

Package: geodlna
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: GeoDLNA es una implementacion GTK para el demonio Minidlna que se encarga de enviar contenido multimedia a dispositivos que soporten tecnologia uPnP o DLNA.


Como pueden notar en el archivo anterior en donde dice Buil-Depends ponemos las dependencias del programa en este caso depende de Python superior a 2.7 y del demonio minidlna si estos no se encuentran instalados no podrá construir el .deb

COPYRIGHT
(EN ROJO LO MÁS INTERESANTE Y RELEVANTE EN EL CAMBIO)

Format: http://dep.debian.net/deps/dep5
Upstream-Name: Geodlna
Source: <http://geowworld.blogspot.com>

Files: *
Copyright: <2011>

License: <GPL v3>

Copyright: 2011 Jorge Guerrero

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see .

DIRS
(EN ROJO LO MÁS INTERESANTE Y RELEVANTE EN EL CAMBIO)

usr/geodlna
usr/share/geodlna
usr/share/applications



Este archivo usualmente esta vació y se puede dejar así pero a mi me gusta simplificar otro archivo y por eso creo este donde pongo los directorios que se crearan o buscaran.

Llegamos ahora al archivo más importante de todos RULES.


RULES
Este archivo es el más complejo y el mas difícil de tratar, encontraran en internet muchos debates de como hacerlo, que existen programas que lo hacen y aplicaciones para construirlo y demás, pero yo prefiero crearlo desde cero y lo explico paso a paso y creo que me ha funcionado con 6 o 7 programas en python con distinto grado de complejidad.

Cuando uno construye .deb o sources de paquetes que ya existen por ejemplo de totem o empathy o cualquier programa que se imaginen ya existente este archivo tiene una forma como esta:

%:
dh $@ 

Para esos caso ese archivo solo se deja con eso y debuild se encarga de construirlo usando ./configure make y make install y esas cosas complicadas o incluso autogen con las que no queremos lidiar.

En el caso de PYTHON se pueden usar scripts complejos o programas para crearlo pero aquí esta mi tip de hoy, lo mas relevante en ROJO y lo que usualmente tenemos que cambiar cuando vamos a construir un nuevo programa de Python.

#!/usr/bin/make -f
# -*- makefile -*-

# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1

configure: configure-stamp
configure-stamp:
dh_testdir
touch configure-stamp

build: build-stamp

build-stamp: configure-stamp
dh_testdir
touch build-stamp

clean:
dh_testdir
dh_testroot
rm -f build-stamp configure-stamp
dh_clean

install: build
dh_testdir
dh_testroot
dh_clean -k
dh_installdirs

#Se pone el nombre que tendrá la carpeta que tendrá al programa dentro.
mkdir -p $(CURDIR)/debian/geodlna
cp geodlna.py $(CURDIR)/debian/geodlna/usr/geodlna
#Crea una carpeta para los datos y copia la actual de datos a esa
mkdir -p $(CURDIR)/debian/geodlna/usr/share/geodlna
cp -r data/ $(CURDIR)/debian/geodlna/usr/share/geodlna

#Copia el archivo .dekstop ejecutable
cp GeoDLNA.desktop $(CURDIR)/debian/geodlna/usr/share/applications

#Instalando los archivos de documentacion o ayuda (no aplica para este programa)
# mkdir -p $(CURDIR)/debian/geodlna/usr/share/doc/geodlna
# cp readme.txt $(CURDIR)/debian/usr/share/doc/geodlna/readme.txt


# Aquí se puede definir si se desean crear multiples binarios 32 bits o 64 bits, por defecto crea para nuestra arquitectura actual
binary-indep: build install

# Build architecture-dependent files here.
binary-arch: build install
dh_testdir
dh_testroot
dh_installchangelogs 
dh_installdocs
dh_installexamples
# dh_install
# dh_installmenu
# dh_installdebconf 
# dh_installlogrotate
# dh_installemacsen
# dh_installpam
# dh_installmime
# dh_installinit
# dh_installcron
# dh_installinfo
dh_installman
dh_link
dh_strip
dh_compress
dh_fixperms
# dh_perl
# dh_python
# dh_makeshlibs
dh_installdeb
dh_shlibdeps
dh_gencontrol
dh_md5sums
dh_builddeb

binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary install configure

Vamos a terminar, se que deben estar cansados como yo en este punto pero ya casi terminamos

Volvemos a la terminal y ejecutamos

debuild

Si dice que no existe lo instalan con:

sudo apt-get install debuild

El programa en un punto nos va a pedir nuestra contraseña para la clava PGP y con eso terminara. Mostrando un archivo .deb como resultado. En este punto ya cumplimos la primera mision del tutorial que era crear un .deb.



El procedimiento anterior es solo para crear .deb pero si nuestra misión es agregar archivos a un repositorio PPA entonces antes de ejecutar en el terminal:

como debuild

Tenemos que ejecutar

debuild -S

Con eso creara las fuentes del programa y estas son las que le importan a Launchpad. Para subirlo al ppa simplemente desde la terminal le damos

dput ppa:geojorg/geo-minidlna geodlna_0.1-1_source.changes

Donde ppa:geojorg/geo-minidlna es el nombre que le pongamos a nuestro respositorio, con esto hemos terminado, ya launchpad se encarga de enviarnos un correo confirmando y dentro de unas 10 a 12 horas crea los paquetes deb para 32 bits y 64 bits de oneiric.

Cualquier duda adicional en los comentarios, gracias.

8 dic. 2011

Tutorial para Crear un PPA

Recientemente he comenzado un proyecto bastante pequeño de una nueva aplicación en Python de la que quizás comente en el futuro o hasta escriba un Tutorial, pero el tema hoy es como crear un PPA.

Seguramente ya muchos saben que Ubuntu usa algo llamado PPA, pero que es y como funciona es cosa que a veces algunas personas ignoran. PPA (Personal Package Archive) es básicamente un repositorio de paquetes personales que permite usarlo para distribuir aplicaciones a usuarios de Ubuntu o Debian.

Como funciona ?. Bueno básicamente es bastante simple lo que hacer es tomar archivos fuentes y convertirlos en .deb ya sea de 32 bits o 64 bits para distribuirlos. Suena interesante y hasta fácil, pero la cuestión es que no existe en internet documentación SIMPLE que permita a un usuario promedio que esta comenzando a crear programas usar un PPA, la de Ubuntu es linda pero para desarrolladores y usuarios muy avanzados y la del resto del internet es tan compleja que me he propuesto mostrarlo de forma muy facil.

Por eso estamos aquí explicando de forma SIMPLE como crear un ppa y subir archivos.

Que vamos a necesitar.
Thunderbird (Programa de Correo Electronico)
Enigmail (Extension de Thunderbird)
Seahorse (Programa de Contraseñas)
Ubuntu Open ID (Si tienes Ubuntu One ya tienes Open ID de Ubuntu)

Lo primero que tenemos que hacer es es crear una contraseña PGP o mas conocida como llave publica para ello escribimos Contraseña o Seahorse en el Dash.
Como se ve en la imagen a continuación.

Cuando tengamos abierto el programa le vamos a dar en nueva y seleccionamos Clave PGP que como dice en la imagen es usada para cifrar correos y archivos.

Ahora creamos la clave poniendo el nombre y el correo electrónico que debe ser el mismo que tenemos registrado en Ubuntu One o Launchpad. Le damos crear y el proceso arranca, este toma algún tiempo así que hay que tener paciencia.

El siguiente paso es ir a la pestaña de mis claves personales y podemos notar que la clave ya fue creada con éxito.

Después vamos al menú y sincronizamos y publicamos la clave. Esto lo haremos en el servidor de Ubuntu, aunque existen muchos otros servidores públicos para almacenar claves.


En esta parte seleccionamos Ubuntu ya que queremos vincular la clave con Launchpad mas adelante. Cerramos esta ventana y le damos en la opción sincronizar.


Ahora ya nuestra clave es publica y esta dentro del sistema de almacenamiento de claves de Ubuntu, lo que mas nos interesa de todo este proceso es obtener la huella de la clave esta huella si es privada y no debe ser mostrada para garantizar la seguridad esta huella la usaremos dentro de la pagina de Launchpad, como voy a mostrar a continuación.

Primero obtener la huella.

La copiamos y nos vamos para la pagina de Launchpad a firmar el acuerdo de conducta que lo pueden abrir aquí.


Esto nos lleva a la siguiente pagina. Donde le vamos a dar registrar una nueva llave Publica open PGP.


Cuando hemos ingresado metemos la huella que hemos copiado anteriormente y la importamos, como ya esta es publica nos enviara un correo electrónico.


Ahora abrimos el Thunderbird al que ya le debemos haber instalado Enigmail que permite descifrar mensajes codificados. Este mensaje nos envia a un link donde finalmente confirma todo y hemos terminado la primera parte.

Cuando le damos en descifrar nos pregunta la contraseña y el correo deja de estar codificado y nos da un link al cual debemos entrar.

Ahora bajamos el código de conducta y lo firmamos con la firma digital, en Launchpad están los pasos.

Con esto terminamos el procedimiento inicial para crear un repositorio, ya podemos ir a launchpad y decirle que cree un nuevo repositorio con el nombre que queramos.

En la segunda parte de este tutorial comentare como crear archivos fuente y como subirlos a launchpad para que este cree los .deb en 32 bits y 64 bits.