Nosinmiubuntu | Ubuntu en concreto, GNU/Linux en general

Instalar GIT en Ubuntu, sistema de control de versiones

2012-02-22T13:08:00.001+01:00

Buenas, hasta ahora siempre he trabajado en empresas pequeñas donde la programación en ciertos aspectos era un poco de andar por casa. Sobre todo lo que se refiere al control de versiones. Este se hacía de una manera muy manual, con un excel donde apuntábamos lo que íbamos cambiando y avisándonos unos a otros cuando trabajábamos en un archivo de un proyecto compartido entre varios. Esta forma de trabajar siempre hará que cometamos errores debido a la falta de documentación en el excel o por la necesidad de modificar archivos por tareas de mantenimiento pero que se están modificando para un desarrollo.

Hasta ahora nunca había trabajado con ningún control de versiones, pero llevaba bastante tiempo escuchando hablar de ellos, sobre todo GIT. Así que ahora me he decidido a montarme mi propio servidor personal git.

Git ha sido desarrollado ni más ni menos que por el propio Linus Torvalds, y es utilizado para el nucleo de Linux entre otros muchos proyectos importantes. El desarrollador que va a trabajar en un determinado proyecto descarga una copia a su pc del proyecto, realiza los cambios necesarios y puede enviar después sus cambios. Otro de los aspectos importantes es que podremos crear una rama de nuestro proyecto, por lo que podremos hacer varias variantes de un desarrollo y escoger cual es la que queremos enviar a nuestro repositorio. Hoy veremos como instalarlo y poco a poco iremos viendo los comandos necesarios para trabajar con git.

Empezamos instalando los paquetes necesarios, entre los que tenemos 2 de git: git-core y gitweb (uno es el núcleo y otro la interfaz web), otro para el server SSH y apache. Con el siguiente comando instalaremos todo.

# aptitude install apache2 git-core gitweb openssh-server

Ahora debemos crear un directorio para el repositorio de git /var/cache/git y otro para la interfaz web gitweb.cgi /var/www/git

# mkdir /var/www/git
# [ -d “/var/cache/git” ] || sudo mkdir /var/cache/git

Ahora vamos a crear un archivo de configuración en Apache para nuestro servidor git.

# nano /etc/apache2/conf.d/git

Y escribimos la siguiente configuración dentro de este archivo:

<Directory /var/www/git>
Allow from all
AllowOverride all
Order allow,deny
Options ExecCGI
<Files gitweb.cgi>
SetHandler cgi-script
</Files>
</Directory>
DirectoryIndex gitweb.cgi
SetEnv  GITWEB_CONFIG  /etc/gitweb.conf

Ahora debemos mover los archivos gitweb.cgi, .css y .png de git a /var/ww/git

# mv -v /usr/share/gitweb/* /var/www/git
# mv -v /usr/lib/cgi-bin/gitweb.cgi /var/www/git

Y debemos hacer algún cambio en el archivo de configuración debido a los archivos movidos en /etc/gitweb.conf, abrimos el archivo con el editor nano y modificamos el archivo así:

# nano /etc/gitweb.conf

$projectroot = '/var/cache/git/';
$git_temp = "/tmp";
#$home_link = $my_uri || "/";
$home_text = "indextext.html";
$projects_list = $projectroot;
$stylesheet = "/git/gitweb.css";
$logo = "/git/git-logo.png";
$favicon = "/git/git-favicon.png";

Por último volvemos a recargar la configuración de Apache:

# /etc/init.d/apache2 reload

Ya está montado nuestro control de versiones git y la interfaz web, podemos comprobarlo llamando a la siguiente dirección desde nuestro navegador: http://localhost/cgi

Ahora vamos a crear un proyecto.

# cd /var/cache/git/
# mkdir proyecto.git
# cd proyecto.git

Iniciamos un nuevo repositorio y lo configuramos. Dentro de la carpeta de nuestro proyecto se creará la carpeta .git que es la que contendrá información para git.

# git init
# echo “descripción del proyecto” > .git/description
# git config -global user.name “Tu nombre”
# git config -global user.email “tu@correo.com”
# git commit -a

Si ahora volvemos a llamar la interfaz web veremos que aparece el repositorio que hemos creado. Ahora para marcar un repositorio como exportado se utiliza el archivo git-daemon-export-ok

# touch .git/git-daemon-export-ok

Ahora iniciaremos un servicio que hará publico nuestro repositorio.

# git daemon -base-path=/var/cache/git -detach -syslog -export-all

Ahora nuestro repositorio está en el puerto 9418, y le daremos permisos a un usuario diferente de root.

# adduser usuariogit
# passwd usuariogit
# chown -Rv usuariogit:usuariogit /var/cache/git/proyecto.git

Por último, para descargar el repositorio basta con la siguiente instrucción:

# git clone git://ip_servidor/proyecto.git proyecto

Ahora ya tenemos una copia en nuestro pc del proyecto con el que podremos trabajar para luego enviar los cambios al repositorio. La semana que viene veremos en más detalle como trabajar con git.

El Escritorio del Lector #64

2012-02-19T23:27:00.000+01:00

Finalizando la semana ya estamos aquí con una nueva edición de "El Escritorio del Lector". Sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

El protagonista de hoy es Kelvin Feliz, quien nos explica un poco los motivos de la elección de las características de su escritorio.

Nos comenta:

"Como muchos usuarios he usado Gnome Shell y Unity, pero ninguno cumplía con mis expectativas en cuanto a rendimiento, así que probé xfce y estoy encantado. Si lo hubiese conocido antes de Gnome 2x seria mi favorito desde aquel entonces, así que le he dado una tuneada para compartirlo para motivar a usuarios a usarlo"

S.O.: Xubuntu 11.10

Tema: Plastiq

Emerald : A New Hope Dark Mod

Iconos: AwOken

Fondo de escritorio: Wallbase

Otros ingredientes: Cairo Dock, Cover Gloobus y Conky

Desde aquí os animo (algo que agradezco de antemano) a participar enviando vuestra captura o capturas con sus correspondientes características, como Sistema Operativo, Fondo de Escritorio, Tema de Ventanas y Tema de iconos a nosinmiubuntublog@gmail.com

Saludos.

Navegando en nuestra aplicación Android

2012-02-15T13:17:00.001+01:00

Buenas, la entrada de esta semana, es de esas sencillas pero bastante prácticas. Hoy veremos como navegar entre diferentes activitys.

Normalmente, una aplicación cualquiera suele tener más de una pantalla, bien porque añadimos una pantalla de configuración, porque tenemos una lista y un detalle, o un menú enlazado a sus diferentes pantallas.

Lo primero que vamos a hacer es crear un nuevo proyecto, yo le he llamado Navigation, y mi activity de inicio se llamará NavigationActivity. Y ahora crearemos dos activitys más, una de ellas le llamaremos NavigationDetail y la otra NavigationResult, para hacer esto basta ir a crear una clase nueva y hacer que herede de Activity.

También hemos de crear dos nuevos layouts para estas activitys, para ello en la carpeta layout hacemos botón derecho y creamos un nuevo archivo, yo les llamaré navigationdetail.xml y navigationresult.xml. El contenido inicial lo podemos copiar del layout main.xml que ha creado al hacer el proyecto.

el código que hemos de añadir en un principio para nuestras activitys es muy sencillo, simplemente debemos decirle cual es el layout que debe llamar, poniendo navigationdetail o navigationresult según sea el caso.

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.navigationdetail);
    }

Por último, debemos decirle a nuestra aplicación que tenemos estas dos nuevas pantallas de nuestra aplicación, para ello abrimos el archivo AndroidManifest.xml, en la vista de código debéis localizar el tag <application>, dentro de este es donde se declaran todas las activitys de nuestra aplicación. Como veis, por defecto ya está declarada nuestra activity principal, la cual además tiene un par de tags que indican que será la activity que se lanzará en el inicio de la aplicación. Si quisierais cambiar vuestro activity principal, simplemente deberéis llevaros estos tags a la activity principal.

Para declarar una nueva activity es muy sencillo, dentro del tag <application> definis un nuevo tag <activity>, que en nuestro caso quedaría de la siguiente forma:

<activity android:name=".NavigationDetail" />
<activity android:name=".NavigationResult" />

Una vez hecho esto nos falta navegar de una pantalla a otra. Para ello vamos a hacer una clase que nos ayude a centralizar las llamadas de navegación que llamaremos NavigationManager. En principio va a tener el siguiente código:

public static void navegarAActivityPrincipal(Activity activity){
  activity.finish();
  Intent itemintent = new Intent(activity, NavigationActivity.class);
  activity.startActivity(itemintent);
 }
 
 public static void navegarAActivityDetail(Activity activity, int id1, int id2){
  activity.finish();    
  Intent itemintent = new Intent(activity, NavigationDetail.class);
  Bundle b = new Bundle();
  b.putInt("id1", id1);
  b.putInt("id2", id2);
  itemintent.putExtra("android.intent.extra.INTENT", b);
  activity.startActivity(itemintent);
 }
 
 public static int getId1(Activity activity){
  int id1 = 0;
  Intent startingIntent = activity.getIntent();
        if (startingIntent != null)
        {
         Bundle b = startingIntent.getBundleExtra("android.intent.extra.INTENT");
         if (b != null) {
          id1 = b.getInt("id1");          
         }
        }
        return id1;
 }
 
 public static int getId2(Activity activity){
  int id2 = 0;
  Intent startingIntent = activity.getIntent();
        if (startingIntent != null)
        {
         Bundle b = startingIntent.getBundleExtra("android.intent.extra.INTENT");
         if (b != null) {
          id2 = b.getInt("id2");          
         }
        }
        return id2;
 }

 private final static int KEY_RESULT = 89865; 
 
 public static void navegarAActivityResult(Activity activity){
  Intent itemintent = new Intent(activity, NavigationResult.class);
  activity.startActivityForResult(itemintent, KEY_RESULT);
 }
 
 public static void returnValueActivityResult(Activity activity, int id1){
  Bundle bundle = new Bundle();
     bundle.putInt("id1", id1);
     Intent mIntent = new Intent();
     mIntent.putExtras(bundle);
     activity.setResult(Activity.RESULT_OK, mIntent);
     activity.finish();
 }
 
 public static int getValueActivityResult(int requestCode, int resultCode, Intent data){
  int id1 = 0;
  if(data != null && requestCode == KEY_RESULT && Activity.RESULT_OK == resultCode){
   id1 = data.getExtras().getInt("id1");  
  }  
  return id1;
 }

Tiene bastantes métodos pero yo prefiero tenerlos todos en el mismo punto para tener un mejor control de la navegación. Todos los métodos son estáticos para que no haga falta instanciar esta clase.

El primer método navegarAActivityPrincipal nos lleva a la activity de inicio. En todos los métodos para navegar definimos un objeto Intent que es una clase que nos permite una activity a ejecutar. En este caso le decimos que es la principal y después llamamos al método startActivity pasándole como parámetro el intent. Lo podemos utilizar así en un Button en nuestra activity NavigationDetail:

btn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
           NavigationManager.navegarAActivityPrincipal(NavigationDetail.this);
      }
});

El segundo método, navegarAActivityDetail, hace casi lo mismo que es el anterior, pero ahora queremos pasarle una serie de parámetros a nuestra activity, para ello nos ayudamos de la calse Bundle a la que le vamos indicando todos los parámetros que enviaremos, y este Bundle se lo añadimos a nuestro Intent para que se lo envíe a la activity que vamos a abrir.

Para recoger estos parámetros utilizaremos los métodos getId1 y getId2, cada uno de estos revisan en el Intent de destino los BundleExtra que indicamos en el método anterior y buscar nuestros parámetros para devolverlos finalmente. Estos dos métodos debemos utilizarlos en el OnCreate del activity NavigationDetail. Para comprobar que funcionan podéis crear un TextView y mostrar los valores que habéis pasado desde otra activity.

@Override
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.navigationdetail);
       
        int id1 = NavigationManager.getId1(this);
        int id2 = NavigationManager.getId2(this);
}

Los siguientes métodos se utilizan cuando desde una activity estamos realizando un proceso que por el medio necesita llamar a otra activity, desde esa nueva activity iniciamos un nuevo proceso que generará un resultado y se lo enviaremos a nuestra primera activity. Por ejemplo, seleccionar una foto o un contacto de nuestra agenda.

El método navegarAActivityResult, hace casi lo mismo que el resto, pero ahora llamamos a startActivityForResult y como segundo parámetro le pasamos una clave que hemos creado en esta misma clase con un código que elegimos nosotros. El cual nos servirá para recoger después el resultado.

El siguiente método, returnValueActivityResult, lo utilizaremos en el activity al que llamamos para devolver el resultado. Simplemente mete en el BundleExtra los valores que vamos a devolver y le decimos que el resultado de la operación ha sido correcto. Si quisierais controlar en la vuelta errores, etc.. podríais hacerlo con los distintos valores de RESULT.

Por último, una vez que hemos regresado a la activity de origen, debemos recoger estos parámetros, para ello debemos hacerlo en el método OnActivityResult, que es el encargado de recoger estas peticiones y procesarlas. Nosotros sobrescribiremos el método con el siguiente código:

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
      super.onActivityResult(requestCode, resultCode, data);
      int id1 = NavigationManager.getValueActivityResult(requestCode, resultCode, data);
}

Con estos pocos casos podeis controlar la mayor parte de la navegación de una aplicación. Por último deciros que es en la clase NavigationManager donde deberiais añadir las llamadas para registrar como navegan los usuarios por vuestra aplicación. Si os acordáis vimos como hacerlo la semana pasada con Google Analitycs.

El Escritorio del Lector #63

2012-02-12T22:40:00.000+01:00

Mariano Cabrera es el protagonista de hoy, quien nos comenta que usa Cinnamon, un Fork basado en Gnome Shell, que hace al usuario tener un entorno muy similar a Gnome 2. Además nos aclara que también es usario de Unity y Gnome Shell.

S.O.: Ubuntu 11.10

Entorno de escritorio: Cinnamon 1.2

Tema: ElementaryOS

Iconos: Ambiance

Fondo: Fiat 500 Abarth

Saludos.

Instalar R (paquete estadístico) desde código fuente

2012-02-09T19:30:00.006+01:00

R es un entorno libre orientado al cálculo estadístico que utiliza los lenguajes de programación C, C++ y Fortran para realizar las tareas solicitadas por el usuario, y que se caracteriza por la particularidad de que sus comandos se ejecutan desde una terminal. Instalar R en Ubuntu es realmente sencillo, pues está incluido en los repositorios de esta distribución; nos bastaría con un simple:

sudo apt-get install r-base

y ya tendríamos R instalado en nuestro sistema.

En esta entrada vamos a hacerlo un poco más difícil: instalaremos R desde su código fuente. Así conoceremos los pasos que constituyen el proceso estándar de compilación/instalación en Linux, y que son los siguientes:

./configure
make
sudo make install

Manos a la obra:

1) Nos bajamos el código fuente de R (http://cran.freestatistics.org/src/base/R-2/R-2.14.1.tar.gz).

2) Abrimos una terminal y descomprimimos el archivo R-2.14.1.tar.gz:

$ tar xvzf Descargas/R-2.14.1.tar.gz

3) Entramos en el directorio del código fuente de R y ejecutamos ./configure. Este script comprueba las dependencias necesarias para la compilación; si todas ellas están disponibles se creará un archivo Makefile, necesario para la posterior ejecución de make. En caso contrario, ./configure nos irá detallando qué dependencias faltan:

$ cd R-2.14.1
$ ./configure
configure: error: no acceptable C compiler found in $PATH
See `config.log' for more details

* No hay compilador de C. Lo instalamos (de paso también instalamos make) y probamos de nuevo:

$ sudo apt-get install gcc make
$ ./configure
configure: error: No F77 compiler found

* No hay compilador de Fortran. También lo instalamos:

$ sudo apt-get install gfortran
$ ./configure
configure: error: --with-readline=yes (default) and headers/libs are not available

* No se encuentra la librería de desarrollo (dev) readline:

$ sudo apt-get install libreadline-dev
$ ./configure
configure: error: --with-x=yes (default) and X11 headers/libs are not available

* Falta la librería de desarrollo (dev) xorg:

$ sudo apt-get install xorg-dev
$ ./configure

¡Por fin! Esta vez ./configure nos confirma que ya disponemos de todas las dependencias, pues, como podemos observar, el script completa su ejecución:

4) Lanzamos make, que se encargará de leer y ejecutar todas las órdenes de compilación contenidas en el recién creado Makefile:

5) Compilado. En este punto del proceso, ya podríamos utilizar R sin necesidad de instalarlo a nivel de sistema (para todos los usuarios); sólo tendríamos que hacer ./bin/R :

6) Pero vamos a hacer que esté disponible para todos con sudo make install :

Con el comando which confirmamos que el ejecutable de R se encuentra en /usr/local/bin.

Saludos.

Google Analytics en Android

2012-02-08T13:21:00.002+01:00

Buenas, hace poco he integrado las estadísticas de Google Analytics en una aplicación que estoy preparando. La verdad es que visto al final, el proceso no parece muy complicado, pero ir siguiendo los diferentes pasos a través de diferentes páginas y en inglés puede llegar a ser un tema que se le puede atragantar a más de uno. Hoy veremos como hacer esto en unos sencillos pasos.

Lo primero que tenemos que hacer es acceder con nuestra cuenta Google en la web de Google Analytics. Las pasos a seguir los voy a hacer con la nueva interfaz de Google por lo que puede variar algo para los que teneis la antigua. Pinchamos en el icono de administración de cuentas (barra naranja a la derecha), ahi teneis un botón para crear una cuenta nueva. Por cada una de vuestras aplicaciones creareis una.

Para los que ya han añadido estas estadísticas en una página web, deciros que son los mismos pasos, solo que con alguna pequeña diferencia. Le damos nombre a nuestra cuenta e indicamos que no es una página web, aunque podéis poner que es una web e inventaros el dominio, por ejemplo con el espacio de nombres de vuestro proyecto o con un subdominio de alguna web vuestra.

Una vez rellenado todo, guardamos, y nos quedamos con el id de seguimiento, olvidándonos de todo el javascript que nos da (solo es necesario si lo integramos en una web). Además nos muestran un botón para descargar el SDK de Android. Desde aquí vais a la zona de descargas y descargais la versión para Android.

Descomprimimos el archivo, dentro de este tenemos un archivo libGoogleAnalytics.jar y algún ejemplo para integrar en nuestras aplicaciones. Lo que hago normalmente es en la carpeta donde tengo mis proyectos, tengo una carpeta libs para tener a mano siempre estas librerias que voy descargando.

Lo que si que teneis que hacer es abrir vuestro proyecto, y crear una carpeta llamada libs en el raíz de la aplicación, y colocar aquí el archivo .jar. Ahora hacemos botón derecho sobre el nombre de nuestro proyecto y vamos a Properties -> Java Build Path -> Pestaña Libraries -> Botón add jars... en la pantalla que aparece buscamos nuestro proyecto y seleccionamos el archivo jar de la carpeta libs, y aceptamos todo.

Ahora en el archivo AndroidManifest.xml añadimos los siguientes permisos para que la librería pueda funcionar, acceder a internet y comprobar el estado de nuestra conexión para registrar las visitas.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Y vamos a crear una clase para que sea más sencillo utilizar las estadísticas en toda nuestra aplicación, le llamaremos AnalyticsManager:

private GoogleAnalyticsTracker tracker;
 private String UA_Code;
 private int frecuencyUpdateGoogle = 60;
 private Context context;
 
 private GoogleAnalyticsTracker getTracker(){
  if(tracker == null){
   tracker = GoogleAnalyticsTracker.getInstance();
   tracker.startNewSession(UA_Code, frecuencyUpdateGoogle ,this.context);
  }
  return tracker;
 }
 
 public AnalyticsManager(Context context,String UACode){
  this.context = context;  
  this.UA_Code = UACode;
 }
 
 public void registerPage(String page, String parameter){
  this.getTracker().trackPageView("/" + page+ "/" + parameter);
 }
 
 public void registerPage(String page){  
  this.getTracker().trackPageView("/" + page);
 }
 
 public void registerAction(String Category, String Action, String Label, int Value){
  this.getTracker().trackEvent(Category, Action, Label, Value);
 }
 
 public void stopTracker(){
  if(this.getTracker() != null)
   this.getTracker().stopSession();
 }
}

La clase no es muy extensa, en el constructor le pasamos el context donde estamos y el id de seguimiento o UA_Code de Google. El UA_Code lo podéis guardar como una variable global, como veremos después, y de esta forma podéis exportar esta clase a cualquiera de vuestros proyectos. La frecuencia de refresco está en 60 segundos, si lo creéis oportuno, ajustad este parámetro a vuestras necesidades.

Para registrar estadísticas tenéis el método registerPage al cual podéis indicar el nombre de la página, aquí será una activity, a la que navega el usuario, y podéis indicar también un parámetro más por si es una vista que muestra el detalle de algún ítem, y podáis saber hacia cuales navegan vuestros usuarios.

El otro método es registerAction y va a permitirnos registrar cuales son los botones, acciones etc... que más utilizan los usuarios. Podemos indicar la categoría, acción, etiqueta y valor de nuestros botones.

Llegados a este punto ya tenemos totalmente operativa nuestra aplicación, a partir de aquí sería tan fácil como instanciar esta clase y llamar a estos métodos cuando los necesitemos. Advertiros que Google no va a empezar a reflejar el histórico de las estadísticas hasta pasado un día, pero, hay una opción en la que podéis ver las estadísticas en tiempo real de los últimos 30 minutos y no necesitáis esperar un día para saber si está funcionando o no las estadísticas.

Ahora os voy a enseñar como registro en mi aplicación las estadísticas. Por un lado me creo una clase AppGlobals que hereda de Application y me permite acceder a propiedades u objetos que quiero tener de forma global en mi aplicación. Una vez creada teneis que abrir el archivo AndroidManifest.xml y en la pestaña Application chequeais la opción Define an <application> tag in the AndroidManifest.xml y en Name pinchais en Browse y os aparecerá la clase AppGlobals, la seleccionais y guardais.

En la clase AppGlobals vamos a tener el siguiente código, los métodos son static, de esta forma no es necesario instanciar esta clase para llamarlos:

public static String getUACodeAnalytics(){return "UA-xxxxxxxxx-x";}
private static AnalyticsManager analyticsManager = null;

public static AnalyticsManager getAnalyticsManager(Context context){
 if(analyticsManager == null)
  analyticsManager = new AnalyticsManager(context,getUACodeAnalytics());
 return analyticsManager;
}
 
public static AnalyticsManager getAnalyticsManager(){
 return analyticsManager;
}

Lo que estamos haciendo aquí es utilizar el AppGlobals para poder llamar la clase analytics, está ya se encarga de crear el objeto y pasarle el UA_Code si es necesario, de esta forma utilizarlo desde nuestras activitys es muy fácil, solo tenemos que hacer una llamada más o menos así pero utilizando registerPage o registerAction según vuestras necesidades y con los parámetros que consideréis oportunos:

AppGlobals.getAnalyticsManager(this.getApplicationContext()).registerPage("MainMenu");

Para abrir una nueva activity también suelo tener una clase donde tengo todas las llamadas a mis activitys localizadas, de esta forma si tengo que cambiar, como por ejemplo el nombre de la visita solamente hago el cambio aquí. Este es un tema diferente que no voy a tratar aquí pero seguramente no tardaré en hacerlo.

Instalar un servidor DHCP en Ubuntu

2012-02-07T19:00:00.004+01:00

Comenzamos la parte práctica de los 2 últimos artículos, para así tener nuestro servidor DHCP en casa, o en cualquier entorno doméstico, configurado a nuestra manera, cubriendo nuestras necesidades y librándonos de asignar manualmente las opciones de red.

Tenemos nuestro Ubuntu preparado, así que vamos a ver los pasos de la instalación del servicio.

Requisitos

Lo primero es entender el concepto de las direcciones IP.

Saber para qué sirve un servidor DHCP.

Tener instalado el webmin, y que ya te explicamos cómo. (También te puede interesar potenciar webmin).

Asignar una IP fija (o estática). Es recomendable (obligatorio) para todos los tipos de servidores que montemos en un ordenador, tenerlos localizados siempre en la red. Así que si no está asignado ya, aquí tenéis el artículo dónde podréis cambiar la IP.

Detalles a tener en cuenta

Lo normal en una red local, es que nuestro router funcione como servidor DHCP y asigne la configuración de red. Con lo cual, si tenemos este servicio funcionando, es recomendable que se desactive. Esto se debe a que no se puede asignar una dirección IP a dos ordenadores, y si esto ocurre, da un error de conflicto de IP. Y el que primero la tenga asignada, se quedará con ella,y el segundo se quedará con una dirección alternativa.

También debemos planificar nuestro mapa de equipos en la red, y sus respectivas asignaciones de IP.

Otro detalle más que obvio, es que si el servidor en dónde lo instalamos está apagado, ningún ordenador que se conecte posteriormente recibirá la información de red, y obviamente, no tendrá acceso a la misma.

Instalación

Lo primero, es instalar el software que nos permita que nuestro ordenador funcione a modo DHCP. Para ello, como buenos usuarios de ubuntu que somos, utilizaremos el terminal.

$ sudo apt-get install dhcp3-server

Con esto instalaremos el software que necesita el ordenador, y si necesitamos dependencias:

$sudo apt-get install -f

Ya está. Simple ¿no?

El siguiente paso (como ya tenemos instalado webmin) es entrar en él:

https://localhost:10000

Y una vez dentro refrescaremos los módulos, y nos dirigiremos a la pestaña de servidores, y comprobaremos que lo reconoce.

Dejamos esta semana la publicación aquí, y en una semana, nos ocuparemos de configurarlo!

Es mucho más importante esa parte que ésta, pero sin este artículo no se puede realizar la segunda.

Un saludo.

La importancia de las actualizaciones

2012-02-06T22:11:00.000+01:00

Si hay algo que aventaja claramente a Ubuntu con respecto a otras distribuciones es su frecuencia de actualización; cada pocos días aparecen nuevas versiones de los diferentes elementos que integran este sistema operativo, así como parches que aportan mejoras o funcionalidades extra a las versiones ya instaladas. Además, también es muy importante que el sistema se mantenga actualizado por motivos de seguridad, y aquí es a donde yo quería llegar...

No hace mucho, el amigo de Así somos Linux me comentó la existencia de un problema de seguridad en el kernel 2.6.39 y superiores, el cual permitía a cualquier usuario convertirse en root o administrador sin conocer su contraseña. Ni corto ni perezoso, decidí buscar el exploit (pequeño programa que aprovecha una determinada vulnerabilidad del sistema) y ponerlo en práctica. El nombre de dicho exploit es mempodipper, fue programado por zx2c4, y se aprovecha de un bug en el manejo de los permisos del directorio /proc/pid/mem, utilizado para leer y escribir directamente en la memoria de los procesos.

Una vez descargados los archivos necesarios, compilé el exploit (ejecutable resultante subrayado en rojo):

Y procedí a ponerlo en marcha. Fijaos en la salida del comando whoami antes y después:

En efecto, me había convertido en root.

Como en muchas otras ocasiones, ya hay un parche disponible, esta vez publicado por el propio Linus Torvalds. Para probar este exploit utilicé BackTrack 5 R1 (32 bits) con versión de kernel 2.6.39.4. Sin embargo, también lo compilé y ejecuté en Ubuntu 11.10 (64 bits) con el kernel actualizado mediante repositorios, y el exploit ya no funcionó.

Un saludo.

El Escritorio del Lector #62

2012-02-05T21:39:00.000+01:00

Para finalizar la semana, y como es ya una costumbre, volvemos con "El Escritorio del Lector". No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

Nuestro visitante #62 es Hereldar, quien muy amablemente nos ha enviado todas las especificaciones, usuario de Kubuntu, y que nos ha enviado una descripción de los motivos de su escritorio, que os cito a continuación:

"Utilizo dos barras verticales para ahorrar espacio en pantalla, soy programador y mi pantalla es demasiado alargada para mi gusto. Al principio probé con una sola barra a la izquierda pero no me gustaba el resultado, al final quedó como veis."

S.O.: Kubuntu

Tema de Plasma: Caledonia

Tema de iconos: Faenza

Decoración de ventanas: Oxygen

Esquema de colores: Norway

Fondo de escritorio: Caledonia for Kubuntu

Particionado GPT

2012-02-02T12:00:00.019+01:00

Muchos de vosotros conocéis las limitaciones del sistema de particionado clásico, basado en un registro de arranque maestro (Master Boot Record o MBR); este método para gestionar/repartir el tamaño de nuestros discos duros se caracteriza por lo siguiente:

1) Se admite un máximo de 4 particiones primarias, o bien 3 particiones primarias y 1 extendida, pudiendo esta última albergar particiones lógicas.

2) Cada partición no puede sobrepasar los 2,2 TB o terabytes de tamaño, por lo que con 4 particiones primarias, o 3 primarias y 1 extendida, nunca podríamos gestionar más de 8,8 TB.

Gracias a Intel y a su proyecto EFI (Extensible Firmware Interface) estas “limitaciones” han pasado a la historia, y escribo limitaciones entre comillas porque, a día de hoy, supongo que pocos usuarios medios necesitan un elevado número de particiones o un disco de 8,8 TB. Este proyecto no es ni mucho menos reciente, pues Intel comenzó a trabajar en él a mediados de los 90, y en el 2005 ya tenían fundación propia, conocida como UEFI (Wikipedia).

Para comprobar si nuestro equipo permite el uso de EFI, haciendo:

(para Ubuntu <= 10.10) zcat /proc/config.gz | grep CONFIG_EFI=
(para Ubuntu > 10.10) cat /boot/config-`uname -r` | grep CONFIG_EFI=

deberíamos encontrar una línea CONFIG_EFI=y.

Con el estándar EFI disponemos de un nuevo método de particionado que nos libera del viejo sistema MBR. Este método se denomina GPT (GUID Partition Table) y, a grandes rasgos, nos aporta las siguientes ventajas:

1) Se admite un máximo de 128 particiones primarias.

2) Cada partición puede llegar a un tamaño de 9,3 ZB o zettabytes (1 zettabyte = 1 billón de terabytes).

Como todavía no dispongo de un disco duro de 10 ZB (ni de 10 TB), vamos a ver un ejemplo de particionado GPT en un disco de 160 GB, donde sobrepasaremos el límite de 4 particiones primarias propio de MBR; para llevar esto a cabo no nos sirve el mítico fdisk, si no que tendremos que recurrir a su pariente cercano gdisk. Instalarlo es tan sencillo como hacer un sudo apt-get install gdisk.

Empecemos:

En este caso, el disco duro es /dev/sdc, así que:

Antes de continuar, es necesario conocer los códigos para cada tipo de partición; para visualizar dichos códigos, pulsamos l + Enter:

El código correspondiente a una partición Linux es 0700, y el perteneciente a una partición Linux Swap es 8200.
Vamos a crear 5 particiones primarias de 10 GB cada una; 4 de ellas van a ser particiones Linux, y la última será una Linux Swap:

Como podéis adivinar, para crear una nueva partición basta con pulsar n + Enter. Sólo necesitamos introducir el tamaño (+10G) y el tipo de partición (0700 ó 8200). Pulsando p + Enter se nos muestran las particiones recién creadas:

Ahí están nuestras 5 particiones primarias. Bastará con teclear w + Enter para salir de gdisk guardando los cambios realizados.

Nota: Sólo he verificado el reconocimiento de particiones GPT en Trisquel 4.0.1, Ubuntu 11.10, Fedora 16, openSUSE 12.1 y BackTrack 5. Para otras distribuciones de Linux, consultad las documentaciones o manuales correspondientes.

Un saludo.

Leyendo servicios web desde Android: JSON

2012-02-01T12:40:00.004+01:00

Buenas, estas dos semanas anteriores vimos como instalar en Ubuntu un entorno de desarrollo para PHP y MySQL y luego creamos nuestro primer servicio web para poder leerlo desde cualquier dispositivo (Android, IPhone, otro sitio web...). La semana pasada nos quedó pendiente ver como utilizar este servicio web en una aplicación Android, así que vamos allá.

En el ejercicio de esta semana lo que vamos a hacer es conectarnos a nuestro servidor, leeremos y parsearemos el JSON que nos devuelva y por último lo guardaremos en base de datos en nuestro dispositivo.

Para los que no tenéis un servidor donde realizar las pruebas no os preocupéis, con vuestro dispositivo y un router wifi podéis probarlo sin problema.

Empezamos. Lo primero que haremos es abrir Eclipse. En un proyecto nuevo crearemos una nueva clase llamada JSONManager la cual va a tener el siguiente método static y public:


 public static JSONObject getJSONfromURL(String url){
     InputStream is = null;
     String result = "";
     JSONObject json = null;
      try{
         HttpClient httpclient = new DefaultHttpClient();
         HttpPost httppost = new HttpPost(url);
         HttpResponse response = httpclient.execute(httppost);
         HttpEntity entity = response.getEntity();
         is = entity.getContent();
     }catch(Exception e){}

      try{
         BufferedReader reader = new BufferedReader(new InputStreamReader(is,"iso-8859-1"),8);
         StringBuilder sb = new StringBuilder();
         String line = null;
         while ((line = reader.readLine()) != null) {
             sb.append(line + "\n");
         }
         is.close();
         result=sb.toString();
     } catch(Exception e){}

     try{
         json = new JSONObject(result);
     }catch(JSONException e){}

      return json;
 }

El método se conectará a la URL que le indiquemos y tratará de leer y parsear la respuesta en un objeto JSONObject. La primera parte del método abre la conexión http y obtiene la respuesta en un InputStream. La segunda parte, lee la respuesta y la parsea con un objeto BufferedReader para poder finalmente pasarla a un String. Este String es necesario en la tercera parte para crear un nuevo objeto JSONObject que será lo que vamos a devolver finalmente.

Para la siguiente parte creamos una nueva clase, la cual voy a llamar JSONParserLibros. Esta clase se va a encargar de leer el servicio ayudado del método anterior y guardar en base de datos. Veamos que es lo que hace.


private Activity activity;
private JSONObject jObject; 
private ProgressDialog progressDialog = null;
private Runnable runReadAndParseJSON;

public JSONParserLibros(Activity a){
   activity = a;
}

public void readAndParseJSONLibros() throws JSONException{
   runReadAndParseJSON = new Runnable() {
      @Override
      public void run() {
       try{
          readJSONLibros();
       } catch(Exception e){}
      }
   };
   Thread thread = new Thread(null, runReadAndParseJSON,"bgReadJSONLibros");
   thread.start();
   progressDialog = ProgressDialog.show(activity, "Descargando información", "Por favor espere",true);
}

private void readJSONLibros() throws JSONException{
   jObject = JSONManager.getJSONfromURL("http://192.168.1.87/android/service.libros.php");
   if(jObject != null)
          parseJSONLibros(jObject.getJSONArray("libros"));
   activity.runOnUiThread(returnRes);
}

private void parseJSONLibros(JSONArray librosArray) throws JSONException{
  for(int i = 0; i < librosArray.length(); i++){
     Libro l = new Libro();
     l.setIdLibro(librosArray.getJSONObject(i).getInt("id"));
     l.setTitulo(librosArray.getJSONObject(i).getString("libro"));
     l.setISBN(librosArray.getJSONObject(i).getString("isbn"));
     l.save(activity);
  }
}

private Runnable returnRes = new Runnable(){ 
 @Override 
 public void run() {
  progressDialog.dismiss();
 }
};

Como veis, tiene bastantes métodos, vamos a ver que hace cada uno. Lo primero que nos encontramos son variables y el contructor de la clase.

A continuación tenemos el método público que utilizaremos para llamar a nuestro servicio readAndParseJsonLibros. Este método crea un nuevo hilo de ejecución dentro del cual se va a hacer la llamada al servicio web, además se inicia una ventana de dialogo que avisará al usuario que se está haciendo una descarga.

La razón de hacerlo en un hilo de ejecución diferente es porque este es un proceso asíncrono que va a depender de diferentes factores como la velocidad de la conexión o de lo que tarde en responder el servidor.

El siguiente método readJsonLibros es private, y va a obtener el objeto JSON resultante de la llamada a nuestro servicio web mediante el método de la clase JSONMananger. Lo que hacemos a continuación es buscar el array de objetos json incluido dentro de libros. Aquí lo que vamos a tener es cada uno de los objetos json libro. Por último, se llama a un objeto Runnable definido al final de la clase que lo que va a hacer es cerrar la ventana de diálogo.

Como veis, he puesto una IP de una red local para hacer la llamada al servicio, esta corresponde al equipo donde he desarrollado el servicio web. En el momento de probar esto, si teneis un router wifi, deberéis activar la conexión wifi en vuestro dispositivo Android y conectaros a vuestra red local para que podáis tener acceso al servicio. En caso de no tener wifi teneis otras opciones como montar el servicio web en un servidor en internet, los datos se descargarán echando mano de vuestra conexión 3G , o también lo podeis probar con el emulador de Android.

Por último está el método parseJSONLibros, este simplemente recorre el array que obtuvimos antes, en cada una de las vueltas se a tener acceso a un objeto json libro, el cual tiene las propiedades: id, libro e isbn. Podemos acceder al objeto mediante librosArray.getJSONObject(i), donde i es la posición que queremos recuperar, y para acceder a las propiedades simplemente con getInt("nombre") o getString("nombre") dependiendo del tipo de dato que tengamos que recuperar.

Por último, en mi caso me he creado un objeto Libro, al cual seteo las propiedades correspondientes y llamo al método save para guardar en la base de datos de la aplicación. No os pongo como sería esta parte porque ya hemos tratado cómo guardar datos en base de datos SQLite también podéis ver el resultado de lo que habéis descargado leyendo los datos de la base de datos.

Para utilizar esta clase simplemente debereis crear una instancia del objeto JSONParserLibros y llamar al método readAndParseJSONLibros en la parte de vuestra aplicación que más os interese. Utilizada en el método OnCreate de una Activity quedaría de la siguiente forma:


JSONParserLibros json = new JSONParserLibros(this);
json.readAndParseJSONLibros();

Uno de los aspectos que debeis tener en cuenta también es la frecuencia con la que se actualizan vuestros contenidos, si los libros se actualizan de media cada 2 días lo que podeis hacer es guardar en las SharedPreferences la última fecha de actualización y en el método público readAndParseJsonLibros verificar que hayan pasado 2 días o más para llamar a vuestro servicio. Cada vez que hagais lectura reescribis esta fecha con la fecha actual.

Bueno, hasta aquí la última parte de esta serie de capítulos dedicados a los servicios web. Espero os sean de ayuda. Por último, os voy adelantando el tema de la semana que viene, como registrar visitas con Google Analytics en nuestra aplicación Android.

DHCP, El asignador de IP

2012-01-31T16:00:00.002+01:00

Continuamos en nuestro camino, y tras ya saber qué es una IP, y para qué sirve en el anterior artículo, hoy vamos a dar un paso hacia más y saber qué es un servidor DHCP y cuáles son sus funciones dentro de una red. Y descubriremos que está basado en el protocolo IP, y que es un servicio muy confortable.

¿Que significan las siglas DHCP?

Las siglas en inglés: "Dynamic Host Configuration Protocol", en español vendría a ser algo así como: Protocolo de configuración dinámica de host. Esto significa en primera instancia, que es un protocolo, un método estándar para que cualquier dispositivo pueda interactuar con este tipo de servicio. También gracias a su denominación, podemos observar que sirve para configurar un host, ya sea éste un ordenador, un móvil o cualquier dispositivo que pueda conectarse a la red. Y la última palabra es "dinámica", esto significa que no es necesario hacerlo de forma manual, que es un proceso automático.

¿Para qué sirve el servicio DHCP?

Este protocolo, permite que haya una comunicación entre un dispositivo conectado a una red y el propio servidor DHCP. Esta comunicación se basa en el formato cliente-servidor mediante el cual un cliente, como puede ser un ordenador, pide cierta información al servidor, que se la asigna mediante unos parámetros previamente asignados.

¿Qué información puede asignar un servidor DHCP a un cliente?

Como ya hemos visto, los servidores brindan información a un cliente (host), con el fin de simplificar las configuraciones de red. Esta puede ser:

Dirección IP
Dirección IP del servidor DNS
Dirección IP de la puerta de enlace
Dirección de Broadcast
Máscara de subred
Tiempo máximo de asignación de IP (en caso de que ésta sea dinámica)

Direcciones IP mediante DHCP

Una de las principales características del servicio de DHCP es asignar las direcciones IP a cada host de la red. Esto se consigue mediante un intercambio de mensajes entre el cliente y el servidor.

El cliente se conecta a la red, y envía un paquete, llamado DHCPDiscovery , el cual se difunde para toda la red, y todos los nodos de la red lo reciben, pero el único que lo procesará, será el servidor DHCP, el resto de los nodos lo ignorarán. Este paquete se manda a toda la red, porque el cliente no tiene porque saber si hay servidor DHCP o no, y si lo hay, tampoco debe saber la dirección IP.

Cuando el Servidor recibe este paquete, éste le responde un DHCPOffer, el cual le sirve unos parámetros iniciales para la configuración.

Al recibir este último paquete, el cliente, emite otro paquete, el DHCPResquest, donde confirma que recibió los parámetros iniciales, y pide al DHCP una dirección IP libre.

El servidor recibe la petición del cliente, y el servidor le asigna toda la configuración de red restante mediante un DHCPACK. Y ya tendrá la configuración de red completada y lista para el uso.

Existen muchos otros paquetes de comunicación DHCP, pero los básicos son estos.

Configurabilidad del DHCP

En este servicio se pueden configurar varias opciones, pero la más configurable sin duda es la dirección IP.

Formas de asignar una IP

Asignación estática: El servidor asigna una dirección IP a una tarjeta de red, mediante su dirección MAC, que es única en el mundo.
Asignación automática: El servidor asigna una dirección IP a un equipo, y éste la mantiene hasta que no la libere el propio cliente.
Asignación dinámica: El servidor asigna las IP aleatoriamente, (entre un rango previamente asignado) y esta asignación tiene un tiempo límite para que la IP se libere y se asigne a otro equipo.

Alternativas al DHCP

Cuando este intercambio de paquetes no llega a buen puerto, el ordenador coge una IP alternativa, pero viene dada por el Sistema Operativo, y no por el servicio DHCP. Esto significa que la IP asignada no va a coincidir con la red.

La próxima semana comenzamos la práctica de Crear un servidor DHCP en Ubuntu, así que tenéis que tener esto claro para entenderlo mejor.

Gablabel, traduce textos desde tu escritorio fácilmente

2012-01-30T21:30:00.000+01:00

Si algo caracteriza a la Comunidad es la cantidad de proyectos que lleva a cabo. Encontramos un gran número de aplicaciones que ésta nos brinda, y las cuales nos facilitan la experiencia de usuario, además de tener a nuestra disposición el código, pudiendo mejorarlas si lo creemos oportuno, ya sea con ideas o directamente trabajando en él.

Uno de estos ejemplos es Gablabel, una aplicación que como su autor nos describe, es un pequeño cliente de escritorio para Google Translator, muy sencillo, ya que funciona como un pequeño navegador.

Su autor es Damián Nohales, desarrollador de software, y uno de los que autores gSharkDown, quien muy amablemente contactó con el blog para darnos a conocer esta simple, pero interesante aplicación. Este programa está desarrollado en el lenguaje de programación Vala y CMake.

Su autor ha alojado el código en Github, y nos comenta que por ahora, sólo pudo compilarlo y empaquetarlo para la arquitectura i386, no estando garantizado que funcione en otra distro que no sea Ubuntu, ya que se hace uso de la biblioteca para los indicadores de aplicaciones, aunque esto es algo que debe arreglar. Existen dos paquetes para las dos últimas versiones de Ubuntu, es decir, tanto para Natty como para Oneiric en su página de Descargas.

Su funcionamiento es el mismo que si estuviéramos usando Google Translate, pero desde nuestro escritorio, disponiendo de algún atajo de teclado como los de la captura, además de poder poner la aplicación a pantalla completa, y como si estuviéramos en el traductor de Google, elegir el idioma al que queramos traducir.

Desde el blog queremos felicitar a Damián, animarle a seguir desarrollando aplicaciones tan útiles, y agradecerle que las ponga a disposición de la Comunidad.

Aprovechando esta entrada, me gustaría comentar que estaremos encantados de publicar información sobre cualquier que programa estéis creando para GNU/Linux.

Saludos.

El Escritorio del Lector #61

2012-01-29T23:48:00.000+01:00

Nuestro visitante número 61, y no por ello menos importante, es Ariel Escobar, quien muy amablemente nos envía sus especifcaciones. Ariel ha optado por Gnome Shell en detrimento de Unity, algo por lo que muchos usuarios han optado, y que como ya hemos comentado en diversas ocasiones, demuestra el poder de elección del usuario.

S.O.: Ubuntu 11.10

Fondo de escitorio: Adwaita

Gnome-Shell: Adwaita

Iconos: Gnome

Cómo crear servicios web PHP

2012-01-25T12:53:00.000+01:00

Buenas, la semana pasada vimos como instalar un servidor LAMP en nuestro Ubuntu y las herramientas necesarias para desarrollar con PHP y MySQL. Esta semana nos ponemos manos a la obra y veremos como desarrollar un pequeño servicio web para poder utilizarlo más tarde desde una aplicación Android y nutrir nuestra aplicación con datos.

Los formatos más utilizados para compartir información mediante estos servicios web son XML (y otros derivados) y JSON. XML es un lenguaje de marcas muy similar al HTML, lo podéis ver normalmente en las fuentes RSS utilizadas para difundir listas de noticias. JSON es un formato ligero de intercambio de datos. Este último da mejores resultados en cuanto a rapidez y procesamiento, por lo tanto utilizaremos este, pero si queréis utilizar XML solamente deberéis cambiar el formato de salida y listo.

Nuestro servicio va a devolvernos una lista de libros, para ellos primero crearemos una base de datos. Abrimos phpMyAdmin para ello en un navegador escribimos http://localhost/phpmyadmin. Vamos a "Base de datos" y creamos una nueva base de datos, le llamaremos android, aparecerá en la lista de la parte izquierda. Pinchamos sobre ella y creamos una nueva tabla llamada libros con 3 columnas: id_libro, libro y isbn. Actualización: ponemos los nombres de las columnas en minúscula para no tener problemas a la hora de leerlo con el script PHP.

Para cada uno de los campos deberéis indicar de que tipo es, id_libro es un INT además como va a ser un identificador será PRIMARY y para que cada vez que insertemos un registro no nos tengamos que preocupar de calcular este dato marcamos la casilla AUTO INCREMENT.

Los campos libro y isbn son de tipo texto, tenemos VARCHAR el cual debemos indicar la longitud máxima, en nuestro caso pondremos 1.000 y 50 respectivamente. Existe otro tipo de dato para texto, TEXT, ideal cuando almacenamos grandes cantidades de texto, como por ejemplo el texto HTML de este artículo.

Una vez creada la tabla la seleccionáis e insertáis 4 ó 5 registros para que luego al crear el servicio podamos comprobar como funciona.

El siguiente paso es crear nuestro servicio para ello abrimos nuestro IDE BlueFish y dentro de la ruta /var/www/ creamos una carpeta android para nuestro servicio. El servicio constará de varios archivos los cuales os iré detallando que es lo que hace cada uno. Para crear cada uno de ellos haremos botón derecho del ratón sobre nuestra carpeta android, seleccionamos archivo nuevo y le damos el nombre correspondiente.

Empezamos con globals.php, el cual va a tener parámetros de configuración, en principio para poder acceder a la base de datos. Como podéis ver he creado una clase config y las propiedades son static, es decir, no necesito crear un objeto config para poder acceder a estas. Como veis PHP soporta programación orientada a objetos, aunque si queréis podéis utilizar programación estructurada.

<?php
class config{
 public static function getBBDDServer() {
  return 'localhost';
 }
 
 public static function getBBDDName(){
  return  'android'; 
 }
 
 public static function getBBDDUser(){
  return 'root'; 
 } 
 
 public static function getBBDDPwd(){
  return 'xxxxxx'; 
 }
}
?>

El siguiente archivo será dbmanager.php, este archivo nos ayudará a gestionar la base de datos y las consultas que hagamos a ella. Lo voy a hacer lo más básico posible para no complicar mucho el ejemplo. Vuelvo a crear una clase dbmanager con el método executeQuery, al que le pasamos una consulta, esta se ejecuta y nos devuelve el resultado.

include_onde

Destacar la instrucción include_once para referenciar nuestro archivo de configuración. Existe también la instrucción include, la diferencia entre ellas es que la primera solo incluye una vez el mismo archivo, lo cual puede dar problemas si se incluye más de una vez.

Para poder utilizar las propiedades de esta clase lo hacemos con el nombre de la clase seguido de :: y el nombre de la propiedad o método.

<?php
include_once('globals.php');

class dbmanager{
 
 public function executeQuery($sql){
  $con = mysql_connect(config::getBBDDServer(), config::getBBDDUser(), config::getBBDDPwd());
  if (!$con)
    {
     die('Could not connect: ' . mysql_error());
    }
  
  mysql_select_db(config::getBBDDName(), $con);
  
  $result = mysql_query($sql);
  
  mysql_close($con);
  return $result;
 }
}
?>

El siguiente archivo es libros.php, otra vez hago los include de los archivos necesarios y creo una clase libros con dos métodos. El primero de ellos getLibros, crea un objeto dbmanager y ejecuta la consulta que hemos construido en el mismo método. Como veis es private por que lo vamos a utilizar únicamente dentro de la clase.

El segundo método getJSONLibros es publico y se encarga de obtener los datos con el método anterior y almacenar el resultado en la variable $result, luego la recorre y construye la estructura JSON con cada uno de sus items, y por ultimo devuelve la variable $json.

Variables PHP

Como veis las variables en PHP se declaran con un $ siempre delante y para utilizar metodos de un objeto que hemos instanciado sería clase->metodo. Si el método está en la misma clase seria $this->metodo.

<?php
include_once('globals.php');
include_once('dbmanager.php');

class libros{

      private function getLibros(){
 $sql = "SELECT l.* ";
 $sql .= " FROM libros AS l ";
 $db = new dbmanager();
 return $db->executeQuery($sql);
     }

     public function getJSONLibros(){
        $json = "";
 $i = 0; 
 $result = $this->getLibros();
 $json .= " { \"libros\" : [ ";

 while($row = mysql_fetch_array($result)){
    if($i > 0)
     $json .= ",";
 
    $json .= " { \"id\" : ".$row['id_libro'].", \"libro\": \"".$row['libro']."\", \"isbn\": \"".$row['isbn']."\" ";    
    $json .= "} ";   
    $i++;
   }  
  
 $json .= " ] ";
   $json .= " } ";  
   return $json; 
    }
}

El último archivo es al que llamaremos para obtener el resultado de nuestro servicio, lo llamaremos service.libros.php. Este archivo es muy simple, únicamente se hace el include necesario, instancia la clase libros e imprimimos el resultado del método getJSONLibros.

<?php
include_once('libros.php');

$libros = new libros();
echo $libros->getJSONLibros();
?>

Por último probamos en el navegador este servicio con la url http://localhost/android/service.libros.php. Debería aparecer el JSON correspondiente, si queréis comprobar que está todo correcto podéis hacerlo en alguna de las webs que lo hacen online, http://jsonlint.com/ por ejemplo.

Ahora ya tenemos listo nuestro servicio listo para poder leerlo con cualquier cliente, en nuestro caso haremos un cliente en Android la semana que viene que lea este JSON y nos lo muestre.

Nuestras amigas las direcciones IP

2012-01-24T14:00:00.028+01:00

Tras haber terminado con éxito el servidor DNS. Comenzamos una nueva serie de artículos, con la finalidad de instalar un servidor DHCP. Pero para poder conseguir esto, primero debemos tener unos conceptos previos. Un servidor DHCP sirve para asignar de manera automática las IPs. En el siguiente artículo entraremos en detalle en los DHCP. Hoy nos tocan las direcciones IP.

¿Qué significa IP y para qué sirve?

IP son las siglas inglesas de Internet Protocol, lo cual significa que es el protocolo que sigue Internet para realizar sus comunicaciones, y en general la mayor parte de las redes informáticas del mundo.

Este protocolo se basa en asignar a cada elemento de la red (ordenador, router, impresora de red, móvil, página web...) una dirección IP compuesta por una serie de números y puntos, y así que el dispositivo esté localizable en la red.

Hoy en día existe una mejora de la IPv4 (la más común a día de hoy), que es la IPv6, que permite tener muchos más dispositivos, y además se agotaron las IPv4 públicas. Nos centraremos en la IPv4 porque es la que nos interesa para los posteriores artículos.

Dirección IP

La direcciónIPv4 (A partir de ahora simplemente IP), es básicamente un número binario formado por 32 bits (32 unos y ceros seguidos) que identifica de forma lógica y estructurada un dispositivo o interfaz en una red de tipo TCP/IP. Se divide en 4 octetos de código binario separados por puntos.

Una dirección IP está dividida en dos, una parte que identifica a la red a la cual está conectada, y la otra identifica el dispositivo de ésa red a la cual pertenece.

Ejemplo:

192.168.0.100

RED   11000000 . 10101000 . 00000000. 01100100 HOST

Esta dirección IP, por sí sola, no nos dice nada. Pero cuando terminéis este artículo, comprenderéis que la parte "192.168.0" identifica a la red, y el resto "100" indica que es el dispositivo 100 de la red 192.168.0. Ahora veremos porqué.

Tipos

La finalidad de este protocolo es identificar y diferenciar unos dispositivos de otros y además unas redes de otras.

Por ello existen varias clases de IP:

Clase A: El primer octeto identifica la red, y los otros tres, el dispositivo. Este tipo de red se utiliza para poder tener muchos dispositivos por red.

En este caso permite por cada red (primer octeto), más de 16 millones de dispositivos, pero sólo 128 redes diferentes.

Se diferencian de una manera básica, estas redes tienen un rango del primer octeto de 10.X.X.X hasta 126.X.X.X.

Clase B: Los dos primeros octetos identifican la red, y los otros 2 los dispositivos. Es un tipo de red equilibrada, permite bastantes redes (16.384), y bastantes host o dispositivos (65.534) por cada red.

Sus rangos son desde: 128.0.X.X hasta 191.255.X.X.

Clase C: Los tres primeros octetos identifican la red, y el último identifica el host. Permite más de dos millones de redes y 254 host por cada red.

El rango para reconocerla es desde 192.0.0.X hasta 223.255.255.X

También se pueden clasificar en públicas o privadas.

Las IP públicas, son las que se venden para poder tener una página web, un servidor o cualquier dispositivo accesible en la red de redes (Internet).

También son las que usamos para que tengamos acceso a Internet, cada proveedor (ISP) de internet nos proporciona una.

Las IP privadas, son las que no son públicas, y se utilizan para crear redes locales, para que no creen conflictos con las públicas. Estas están reservadas por clases:

Clase A: 10.0.0.0 hasta 10.255.255.255

Clase B: 172.16.0.0 hasta 172.31.255.255

Clase C: 192.168.0.0 hasta 192.168.255.255

Las direcciones IP se pueden clasificar según su configuración.

IP fija

Nosotros decidimos nuestra IP (local), definiéndola en la configuración del sistema operativo. En lo referente a Ubuntu podemos cambiarla siguiendo un artículo de mi compañero.

IP dinámica

Un router o un servidor de DHCP asigna una IP a cualquier dispositivo que se conecte a la red. Éste envía unos paquetes por la red y el servidor DHCP le responde con la IP que debe tomar.

Máscaras de Subred

Las máscaras de subred sirven para dividir la parte de red en una dirección IP de la de host. Son también una serie de 32 bits separados en octetos. Pero la diferencia es que la parte de red la indican los unos, y la parte de host la indican los ceros.

Ejemplo

Dirección IP:

Clase C:

192.168.0.100

11000000 . 10101000 . 00000000. 01100100

Máscara de subred:

255.255.255.0

11111111 . 11111111 . 11111111. 00000000

También puedes crear subredes cambiando la máscara, indicando hasta dónde es la parte de red, y dónde es el host.

Y hasta aquí este simple artículo sobre las direcciones IP. Espero que os ayude a entender el entramado de las redes informáticas. Cualquier duda, escribirla en los comentarios e intentaré ayudaros.

Un saludo.

El Escritorio del Lector #60

2012-01-22T23:59:00.001+01:00

Como buen domingo que es, y recuperando la normalidad en lo referente a "El Escritorio del Lector", volvemos con el Escritorio número 60. No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

Nuestro visitante número 60 es Lucas, compañero blogger que sigo tanto en su cuenta Twitter como en su blog, y quien nos envía un Escritorio bastante simplificado y elegante, con un fondo de pantalla muy agradable a la vista, con la distribución ArchBang.

SO: ArchBang

Wallpaper, se puede bajar desde este link

Gestor de ventanas: OpenBox

Tema: Mist

Tema de iconos: Faenza

Aplicaciones: Tint, Conky, WBar y Xcompmgr para efectos de composición.

Prepara tu entorno de desarrollo PHP en Ubuntu: LAMP, phpMyAdmin y BlueFish

2012-01-18T12:42:00.004+01:00

Buenas, normalmente todas las semanas trato algún tema sobre Android, pero esta semana voy a cambiar un poco de tema, pero tengo mis razones. Esta semana voy a hablaros de como preparar vuestro Ubuntu para poder desarrollar con PHP. La razón es que a continuación os hablaré de como realizar un servicio que se comunicará con nuestras aplicaciones Android y nutrirlas de más información.

Para los que no lo sepáis, LAMP viene siendo la abreviatura de: Linux + Apache + MySQL + PHP. Este proporciona un servidor web Apache, un servidor de base de datos MySQL y toda la potencia de PHP para ejecutar nuestros sitios web.

La instalación es muy sencilla, en un terminal debemos ejecutar lo siguiente:

sudo apt-get install tasksel

Esto lo que va a hacer es instalar el mismo paquete que utiliza Synaptic internamente, esto es porque en las nuevas versiones de Ubuntu desde la 10.10 no existe este paquete y debemos instalarlo de forma manual.

Una vez lista la instalación, ejecutamos la herramienta tasksel.

sudo tasksel

Aparecerá una ventana para seleccionar que software queremos instalar, nosotros en nuestro caso vamos a seleccionar LAMP Server (seleccionamos con la barra espaciadora). Empezamos la instalación y en un momento determinado nos pedirá una contraseña para el usuario "root" administrador de la base de datos MySQL, asignáis la que vosotros querrais y continuamos con la instalación.
Importante: si no estáis seguros para que sirve el resto de cosas no las quiteis podeis llegar a desinstalar componentes vitales para vuestro sistema. Muchas gracias a Alejandro Abarca por el aporte.

Una vez listo reiniciamos apache desde la consola.

sudo /etc/init.d/apache2  restart

Para comprobar que todo ha ido bien abrimos un navegador y escribimos en la barra de direcciones "http://localhost", está es la dirección de nuestra propia maquina, podemos acceder también mediante "http://127.0.0.1" o con la IP que tengamos asignada en nuestra red de área local. En cualquier caso, el resultado va a ser el mismo una página web en blanco con el texto "It works!", es la página por defecto que nos muestra Apache.

El directorio raíz donde tienen que estar ubicados nuestros sitios web es /var/www/. Nuestro usuario no tendrá permisos para modificar en este directorio por lo que es recomendable que nos demos algún privilegio para facilitarnos el desarrollo para ejecutamos en un terminal lo siguiente:

~$ cd /var/www/
/var/www$  sudo chown -R usuario .

Con esto último comando estamos haciéndonos propietarios de esta carpeta y todas las que contiene(no olvidéis incluir el punto que va al final). Como recomendación yo suelo tener un enlace a esta carpeta en mi carpeta personal por comodidad y rapidez a la hora de acceder a ella.

Si queréis comprobar y ver la configuración de nuestro servidor podeis crear en /var/www/ un archivo llamado info.php con la siguiente línea:

<?php phpinfo(); ?>

Si ejecutamos esto en nuestro navegador mediante http://localhost/info.php nos mostrará una página con la configuración de nuestro servidor.

Ahora que ya tenemos instalado el servidor, nos hacen falta las herramientas para desarrollar. Lo primero a instalar es una herramienta para gestionar nuestra base de datos, lo más común es phpMyAdmin. Es una herramienta gestionada via web y os recomiendo que utiliceis esta porque los proveedores de sitios web son la que incluyen para gestionar los sitios, de esta forma a la hora de gestionar vuestro sitio web ya estaréis familiarizados con esta herramienta.

Para instalarla ejecutamos en el terminal:

sudo apt-get install phpmyadmin

Y una vez instalada accedemos escribiendo en el navegador: http://localhost/phpmyadmin. Existen otras herramientas como por ejemplo la que nos proporciona MySQL: MySQL Query Browser que también es bastante buena, pero nosotros vamos a centrarnos en phpMyAdmin.

La última pieza para tener completo nuestro entorno de desarrollo es un IDE para desarrollar en PHP. Existen varias alternativas, de las cuales yo me quedo con dos: BlueFish por sencillez y Eclipse + Plugin PDT porque es bastante completo y unifica en un solo IDE la mayoría de los lenguajes con los que personalmente trabajo.

Debido a que el desarrollo en PHP va a ser muy sencillo veremos como instalar BlueFish. Este se puede instalar desde el centro de software de Ubuntu o mediante el comando:

sudo apt-get install bluefish

Y con este último paso terminado ya estamos preparados para empezar a desarrollar con PHP y MySQL. La semana que viene veremos como crear un pequeño servicio que posteriormente utilizaremos en una aplicación Android.

Guía para crear un Servidor DNS en Ubuntu Parte 3 (Última)

2012-01-17T16:38:00.002+01:00

Tras varias semanas aparcado, y yo de vacaciones, retomo la última entrega que os tenía prometida, ya que, por diversos motivos no pude la semana pasada, volvemos con el tema de los DNS, para ya por fin finalizar este tema. Recordamos que si tenéis algunas dudas, explicarlas mediante los comentarios, o la pestaña superior de contactos.

Os dejo los enlaces anteriores por si necesitáis repasarlos antes de continuar con esta guía y dar por terminada la instalación y configuración del servidor:

Introducción a los DNS. ¿Qué son?¿Para qué sirven?
Instalación del DNS en Ubuntu (Parte 1)
Configuración del DNS en Ubuntu (Parte 2)

Si hacemos un poco de memoria, ya sabemos cómo crear zonas en nuestro servidor, tanto directas como inversas. También sabemos ya cómo crear registros en ambas, y dar de alta nodos de nuestra red.

¿Qué vamos a aprender hoy?

Reenvío de peticiones de servidor.
Crear registros de alias (CNAME).
Comprobar errores en el servidor.
Crear una zona subordinada.
Humildes consejos.

Reenvío de peticiones del servidor.

Hasta este momento, nuestro servidor DNS, sólo resuelve los nombres que estén registrados en él. Todo lo que esté fuera de esta área es invisible para el servidor. Esto se arregla simplemente reenviando a otro servidor de nombres aquellas peticiones que el nuestro no encuentre, ya sea un servidor de otra red local, u otro de Internet, como uno público.

Debemos dirigirnos a la página principal del BIND9 de webmin, y una vez allí entraremos en la sección de "Reenviadores y Transferencias"

Nos aparecerán todas las opciones que tenemos para poder reenviar las peticiones que no tengan un destinatario concreto. Lo único que debemos hacer es poner la dirección IP en la cual se encuentra el servidor de red local, o de Internet.

Nota:

Los reenvíos de peticiones, tendrán prioridad según la plaza que ocupen en esta lista que nos muestran. En la imagen: primero buscará en el servidor 192.168.2.150 y tras eso buscará en el servidor 8.8.8.8 y finalmente en el 8.8.4.4

Yo utilizo esos dos servidores, porque son unos DNS de Google, los cuales tienen todas las direcciones públicas de Internet. Pero esos servidores sólo nos servirán cuando queramos resolver dominios de fuera de la red local. Si queremos que resuelvan dominios de otra red privada, debemos reenviar las peticiones al otro servidor local, y que el segundo acepte esas peticiones extra. Finalmente le damos a salvar, y si es necesario reiniciaremos el servicio.

Crear registros Alias (CNAME)

Hasta este momento, para encontrar un ordenador, teníamos que escribir nuestra dirección tal que así (dependiendo de los registros creados):

iscario.nosinmiubuntu.

Con el punto al final, y esto es más cómodo que la IP que era:

192.168.1.101

Pero vamos a darle una vuelta más de tuerca, cuando necesitamos que un equipo esté visible por varios nombres, ya que quizás el trabajador "iscario" se encuentre además en la oficina 1, podemos referirnos a él como cualquiera de los dos nombres mediante este tipo de registros.

Para ello usamos los registros CNAME o alias, los cuales sirven para crear, como su nombre indica, un alias para poder localizar con varios nombres un mismo recurso de red.

Nos dirigimos la página principal de BIND9, y entramos en nuestra zona primaria (en nuestro caso "nosinmiubuntu") y una vez allí, entraremos en la sección de "Alias de nombre".

Una vez dentro debemos escribir el alias que le queramos poner, y en el cuadro de abajo la dirección completa del nodo que queramos crear un alias, es importante que le pongamos el punto final, fíjate bien. Como es lógico, no podemos repetir el nombre original, debemos escoger otro diferente. Finalmente le damos a crear, y nos aparecerá una lista con todos los que hemos creado.

Comprobar errores en el servidor.

Webmin tiene una opción muy simple que comprueba de forma automática si tiene errores los archivos de configuración. Para ello, vamos a la pantalla principal y entramos en la sección "Check BIND Config".

Al acceder a esta sección, webmin comprobará si tiene algún error (no es muy común utilizando webmin, pero puede ocurrir) y si es así, lo mostrará. En mi caso no hay ningún error, por lo cual me muestra un mensaje, notificándome que no tengo ningún error en el archivo de configuración o en las zonas a las que hace referencia.

Crear una zona subordinada.

Las zonas subordinadas sirven para compartir información de un servidor principal, y así poder funcionar como backup o como servidor para balancear la carga.

Para crear una zona así, debemos ir a la página principal de BIND9, en webmin, y una vez allí debemos crear una zona, pero en este caso subordinada.

Entonces, se nos abre la pestaña de creación de zona, en la cual debemos de escribir el nombre de la zona, y asignarle las IPs del servidor del cual debe coger toda la información.

Nota:

Recuerda, que debes poner una IP de la misma red que el servidor principal, para poder transferir esa información. Otra opción es tener correctamente configurado el router. Pero la clave es que el equipo de la zona subordinada tenga acceso al servidor principal.

Finalmente, le damos a crear, y nos aparecerá una vista, como si fuera una zona maestra, podremos consultar los datos del DNS principal, pero no podemos modificarlos, ya que sólo es una zona de apoyo o de copia de seguridad.

Humildes Consejos

Una gran parte de las veces que no funciona algo, debemos parar el servicio BIND9 y volverlo a arrancar. De hecho deberíamos hacerlo en cada modificación que hacemos.
Es muy importante la configuración de red. Si algo está mal configurado, no funcionará y no sabrás porque.
Para que el servidor esté visible en Internet, debemos contratar una IP fija en nuestro ISP (Compañia de ADSL) y configurarlo con las IPs que nos den.
Hay más cosas que no he explicado aquí, porque son más avanzadas, o yo no las veo imprescindibles para el funcionamiento del servidor. Pero recuerda que si usas una máquina virtual, puedes trastear todo lo que quieras, sin estropear la configuración de tu equipo.

Nada más desde aquí. Un saludo, gracias por la paciencia, y espero me disculpéis por la tardanza. Hasta la próxima.

Asturix 4, una distribución muy interesante

2012-01-16T18:07:00.002+01:00

Dentro del universo GNU/Linux existen multitud de distribuciones, algo que para unas personas puede suponer un problema, y para otras algo maravilloso. En el blog nos decamentamos por la segunda opción, ya que tener esta diversidad ayuda a la libertad de elección del usuario y a enriquecer la Comunidad con posibilidades sorprendentes, que nos ayudan a disponer de cualquier herramienta o sistema que podamos imaginar.

Una de estas maravillosas opciones de las que podemos disfrutar es Asturix, distribución basada en Ubuntu, y que nació en 2008 como una idea de Luis Iván Cuende. Nació como una distribución linux regional, pero se ha convertido en una de las más reconocidas a nivel internacional, siendo instalada en más de 20 paises, y haciéndose con múltiples premios y nominaciones, como 2 nominaciones en ediciones especiales de Campus Party (Europa y Granada), desarrollada por el proyecto Asturix.

Gracias a Ricardo López, su delegado de comunicaciones, nos enteramos de la salida de Asturix 4, la cual viene con características tan suculentas como:

Nueva experiencia de usuario. Hemos desarrollado un nuevo entorno de escritorio para mejorar la usabilidad, productividad y ayudarte a permacener concentrado, desarrollado con tecnologías web (como HTML5 o CSS3).

Tiene la mayor paleta de color del mundo por defecto. Gracias a nuestros colaboradores de GiveLifeCS puedes disfrutar de más de 5000 colores cuando estés usando GIMP, Inkscape o cualquier otra aplicación.

Previsualizaciones de todo. Ahora ya no tienes que abrir LibreOffice para ver un documento. Con la barra espaciadora podrás previsualizar cualquier tipo de archivo.

Las redes sociales y de microblogging están integradas, por lo que tendrás fácil acceso a Twitter, Facebook o Identi.ca

Asturix Bridge te permite añadir, modificar y ejecutar aplicaciones web como aplicaciones nativas.

Chromium, LibreOffice, GIMP, Clementine, VLC… tiene todas las aplicaciones que desearás encontrar. Además puedes instalar miles de aplicaciones desde el Software Center.

Música libre y gratuita gracias a Jamendo, integrado en el reproductor Clementine. ¡Es legal!.

Impresionante gestión de escritorios con las teclas Super+S.

Decir que a nivel de requerimientos, como ocurre con la mayoría de distribucionesGNU/Linux, no necesitas equipos muy potentes, teniendo como Requerimientos mínimos 512 MB de RAM y 5 GB de HD, y como Recomendados 1GB de RAM y 10 GB de HD.

Sólo nos queda felicitar a todo el equipo de Asturix por el lanzamiento de esta nueva versión, y desearle toda la suerte del mundo, además de, por supuesto, recomendar que probéis este Sistema Operativo tan interesante.

Saludos.

El Escritorio del Lector #59

2012-01-15T20:57:00.000+01:00

Como ya dijimos ayer esta semana hay doble ración de "El Escritorio del Lector". No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

En la segunda ración de la semana el portagonista es Esteban Ramírez, quien nos muestra un área de trabajo basado en Ubuntu con Gnome Shell como entorno de escritorio, lo que nos demuestra que aunque Ubuntu venga con Unity, y existan quejas al respecto, podemos modificar a nuestro antojo cualquier distribución.

S.O.: Ubuntu 11.10

Tema: Zukini

Iconos: Faenza Cupertino

Fondo de escritorio: Derp

Ademas de algunas extensiones de Gnome Shell

El Escritorio del Lector #58

2012-01-14T19:48:00.001+01:00

Como comentábamos la semana pasada, tuvimos un pequeño parón en lo referente a publicaciones debido a las vacaciones navideñas. Por ello, durante esta semana vamos a publicar "El Escritorio del Lector" tanto Sábado como Domingo, para así cumplir lo prometido a nuestros lectores.

Me gustaría recordar que en esta sección, de la que estoy particularmente orgulloso por la gran aceptación que le habéis dado, aquí el protagonista puedes ser tú, tan sólo tienes que querer mostrar cómo es el área de trabajo donde te manejas, para que el resto conozcamos nuevos paquetes de iconos, temas, etc. Una muy buena forma de compartir vuestro trabajo a la hora de dejar lo más cómodo posible el Escritorio.

Este atípico día para la sección está dedicado a V. Hugo Btt, quien en vez de enviarnos un único Escritorio, nos envía dos, el mtivo no es otro que haberse cambiado de distribución, de Ubuntu a Linux Mint, algo que como bien sabréis aparentemente ha hecho mucha gente debido a Unity. El autor nos ha pedido que pongamos a vuestra disposición su correo por si tenéis alguna duda vhugo.btt@gmail.com

S. O.: Ubuntu 11.04 en LiveUSB

Tema: Ambiance modificado, color de selecciones #772953.

Iconos: Awoken 2.3

En pantalla: Netbook Launcher Efl

S.O.: Linux Mint 11 "Katya"

Saludos.

Día del Usuario Ubuntu, aprende de la Comunidad

2012-01-13T12:00:00.012+01:00

Si hay algo que caracteriza a GNU/Linux en general, y a Ubuntu en concreto es la gran Comunidad que hay detrás. Gracias a ésta disponemos de una gran cantidad de canales con los que obtener información, los cuales sirven de ayuda tanto a la gente que está empezando como a los más expertos.

Uno de estos canales es Ubuntu Classrom, en el cual se crean una serie de charlas en eventos del tipo Ubuntu Open Week. Como gran parte de esta información está en inglés, disponemos de Classroom_ES, en la cual se organizan eventos paralelos en la lengua de Cervantes, gracias a gente como Sergio Meneses o Marcos Costales, además de, por supuesto, los instructores que impartirán las charlas.

En esta ocasión disponemos de la versión en español del Día del Usuario Ubuntu, que como nos describen en su correspondiente wiki, nos es otra cosa que un conjunto de charlas que se van a dar en el correr de un día para que los nuevos usuarios de Ubuntu, con conocimientos básicos e intermedios puedan aprender cosas como:

Cómo instalar Ubuntu.

Encontrar programas equivalentes en Ubuntu.

Cómo obtener ayuda.

Aprender cosas básicas para utilizar Ubuntu.

Aprender como integrarse y colaborar con la comunidad.

Para acceder a las sesiones simplemente tendrás que entrar en los canales #ubuntu-charlas y #ubuntu-charlas-chat de los servidores IRC de freenode irc.freenode.net o seguir el siguiente enlace, donde deberás ingresar un nombre que te identifique (en Nickname) y dar clic en conectar (Connect).

Si quieres saber el horario de las charlas para tu ciudad, da clic en el enlace con la hora UTC, este te mostrará la hora local en tu ciudad.

Instructor	Tema	Horario
SergioMeneses	Apertura de la jornada	17:30 UTC
mimecar	Copias de seguridad: Grsync y Clonezilla	18:00 UTC
costales	Seguridad básica: Cortafuegos Gufw	19:00 UTC
primicachero	Equivalencia programas Windows/Ubuntu	19:30 UTC
LinaPorras	Programas de Mensajería Instantánea en Ubuntu	20:00 UTC
chilicuil	Corrección de bugs I	21:00 UTC
chilicuil	Corrección de bugs II	22:00 UTC

Como siempre que hay este tipo de eventos, desde el blog os animamos a asistir tanto si eres un usuario experto como novato, ya que pueden resultar bastante interesantes, pudiendo interactuar con otros ubunteros que tienen la misma filosofía de compartir.

Saludos.

Arranque múltiple con dispositivos USB

2012-01-12T00:00:00.011+01:00

Cada día que pasa, los dispositivos de almacenamiento USB adquieren más fama, en detrimento de los soportes ópticos como CDs y DVDs; varios son los motivos: mayor velocidad de transferencia de datos, tamaño reducido, ..., y la aparición de equipos informáticos que ya no disponen de unidades ópticas, como puede ser un simple Netbook. Para la instalación de cualquier sistema operativo en uno de estos equipos, lo más habitual es hacer uso de un dispositivo USB preparado para tal fin. Últimamente, y con la proliferación de Live CDs de un buen número de distribuciones de GNU/Linux, también se utilizan dispositivos USB para probar éstas sin alterar los sistemas. Por otro lado, existen multitud de herramientas de diagnóstico, particionado y reparación que pueden ser utilizadas mediante un USB de arranque.

En esta entrada, vamos a ver cómo preparar un dispositivo USB de 2 GB para que nos permita arrancar dos versiones distintas de Ubuntu, sin necesidad de instalación alguna, simplemente a partir de sus imágenes ISO. Para ello, utilizaremos el gestor de arranque GRUB 2. Los pasos a seguir son los siguientes:

1. Instalamos GRUB 2 en el sistema:

sudo apt-get install grub2

2. Conectamos el USB y comprobamos cuál es su punto de montaje y su nombre de dispositivo:

mount | grep /media

En la siguiente imagen aparece subrayado en amarillo el nombre de dispositivo (/dev/sdb) y en azul el punto de montaje (/media/6ABE-30DD):

3. Instalamos GRUB 2 en el USB utilizando los datos obtenidos anteriormente:

sudo grub-install --root-directory=/media/6ABE-30DD /dev/sdb --force

Observamos que en el USB se ha creado un directorio boot :

4. Copiamos al USB las imágenes ISO que vayamos a utilizar (podemos meter cada una de ellas en un directorio o bien dejarlas en el directorio raíz del dispositivo, como hemos hecho en este caso):

5. Entramos en el directorio boot/grub del USB, creamos un archivo vacío y lo renombramos como grub.cfg :

6. Editamos grub.cfg y le añadimos una entrada (menuentry) por cada ISO que queramos incluir en el menú de arranque; en este punto es imprescindible conocer la ruta completa tanto del kernel (vmlinuz) como del disco RAM inicial (initrd), pues ambos pueden variar en función de la distribución elegida:

* El parámetro boot, que figura inmediatamente después de /casper/vmlinuz, hace referencia al directorio donde se encuentra el kernel de la ISO; en este caso, boot=casper, pues vmlinuz está dentro del directorio casper.

Guardamos grub.cfg y ya tenemos listo nuestro USB con arranque múltiple. Podemos añadir las imágenes ISO que queramos, basta con crear una menuentry para cada ISO. El límite está en la capacidad de almacenamiento del dispositivo USB.

Saludos.

Cómo descargar imagenes en Android

2012-01-11T14:27:00.001+01:00

Buenas, la semana pasada vimos como ponerle bordes redondeados a una imagen y hacerla cuadrada, para el ejemplo de utilización de nuestro método utilizamos una imagen ubicada como recurso en la aplicación, y nos quedo pendiente ver como obtener las imágenes desde un repositorio en internet. Esta semana veremos como hacer esto.

Lo primero que debéis hacer antes de nada es darle permisos de internet a nuestra aplicación, esto lo hemos visto en artículos anteriores.

Ahora lo mejor es llevar los métodos que vamos a ver a una clase, yo me voy a crear una llamada ImageManager. Tambien veremos como hacer todo este proceso en un hilo de ejecución diferente del de la aplicación, de esta forma las imagenes se irán descargando y el resto de la aplicación seguirá ejecutandose. Veamos el contructor y las variables que hemos de definir.

private final Map<String, Drawable> drawableMap;

final Context context;

public ImageManager(Context c) {  
     drawableMap = new HashMap<String, Drawable>();
    context = c;
}

Hasta aquí todo es bastante sencillo, estamos definiendo un par de variables en la clase e inicializándolas en el constructor de la clase. Veamos ahora el método principal de la clase, el que se encargará de descargar la imagen.

public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
     
    
    final Handler handler = new Handler() {
 @Override
 public void handleMessage(Message message) {
       imageView.setImageDrawable((Drawable) message.obj);
 }
    };
 
    Thread thread = new Thread() {
  @Override
  public void run() {
      try{
          Drawable drawable = fetchDrawable(urlString);
          Message message = handler.obtainMessage(1, drawable);
          handler.sendMessage(message);
      } catch(Exception e){
          imageView.setVisibility(View.GONE);
      }
  }
    };
    thread.start(); 
}

Como veis el método no es muy extenso. Primero definimos nuestro handler que será el encargado de procesar los mensajes del nuevo hilo de ejecución cuando nuestra imagen se haya descargado y asignársela al ImageView.

Después definimos el hilo(thread), para el cual en un objeto Drawable descargaremos y convertiremos nuestra imagen con el método fetchDrawable, después asociamos el objeto drawable con nuestro handler y iniciamos el nuevo hilo con el método start.

 public Drawable fetchDrawable(String urlString) {
        if (drawableMap.containsKey(urlString)) {
            return drawableMap.get(urlString);
        }

        try {
            InputStream is = fetch(urlString);
            Drawable drawable = Drawable.createFromStream(is, "src"+urlString);
            if (drawable != null) {
                drawableMap.put(urlString, drawable);
                return drawable;  
            } else {
             return null;
            }         
        } catch (MalformedURLException e) {
           return null;
        } catch (IOException e) {
           return null;
        } catch (Exception e){
           return null;
        }
    }

El método fetchDrawable que os he puesto aquí se encarga de verificar si la URL que hemos indicado ya existe en drawableMap, el cual almacena pares llave/valor, y devuelve el drawable correspondiente en caso afirmativo.

Si no teniamos la imagen la descargamos con el método fetch el cuál nos devuelve un objeto de tipo InputStream a partir del cual crearemos el objeto drawable con el método estático createFromStream y lo almacenamos en drawableMap.

private InputStream fetch(String strURL) throws IOException{
 InputStream inputStream = null;
 URL url = new URL(strURL);
 URLConnection conn = url.openConnection();
 
 try{
  HttpURLConnection httpConn = (HttpURLConnection)conn;
  httpConn.setRequestMethod("GET");
  httpConn.connect();
 
  if (httpConn.getResponseCode() == HttpURLConnection.HTTP_OK) {
   inputStream = httpConn.getInputStream();
  }
 }  catch (Exception ex){}
 return inputStream;
}

El método fetch se encarga de abrir una conexión HTTP mediante el método GET, obtener una respuesta y devolverla en un objeto de tipo InputStream.

Hasta aquí el código de nuestra clase, ahora solamente queda utilizarla en nuestra activity, podeis recolectar cualquier imagen de internet en cualquier página, por ejemplo la nuestra haciendo botón derecho y copiando la dirección, y con unos cuantos ImageView vereis como las imagenes se van descargando. Mientras tanto al descargarse en un hilo diferente podeis realizar otras acciones en vuestra aplicación. Os pongo un pequeño ejemplo de uso.

ImageView imageView = (ImageView) findViewById(R.id.image);
ImageManager imageManager = new ImageManager(this);
imageManager.fetchDrawableOnThread("http://.....", imageView);

Si queréis que estas imágenes tengan una permanencia más duradera en vuestra aplicación podéis guardarlas en la tarjeta SD del dispositivo.