Adictos a la Informática - Página 4 de 5 - Nuevas tecnologías y otros bichos

XMPP – OpenFire

Publicado en 10 febrero, 2011 por

ruben Publicado en Sistemas — 1 comentario ↓

Introducción

OpenFire es un servidor de XMPP programadfo en java (multiplataforma) y con un como WebApp para administrarlo. Se encuentra bajo licencia GPL y con el puedes administrar a tus usuarios, compartir archivos, auditar mensajes, mensajes offline, mensajes broadcast, grupos, etc y además contiene plugins para ampliar sus funcionalidades.

Características

Openfire implementa las siguientes características:

Panel de administración web
Interfaz para agregar plugins
SSL/TLS
Conferencias
Interacción con MSN, Google Talk, Yahoo messenger, AIM, ICQ
Estadísticas del Servidor, mensajes, paquetes, etc.
Cluster con múltiples servidores
Transferencia de Archivos
Compresión de datos
Tarjetas personales con Avatar
Mensajes offline
Favoritos
Autenticación vía Certificados, Kerbeos, LDAP, PAM y Radius
Almacenamiento en Active Directory, LDAP, MS SQL, MySQL, Oracle y PostgreSQL
SASL: ANONYMOUS, DIGEST-MD5 y Plain

Instalación

Tan simple como descargar OpenFire Downloads (en nuestro manual un deb):

# wget http://www.igniterealtime.org/downloads/download-landing.jsp?file=openfire/openfire_3.6.4_all.deb

Luego podemos instalarlo fácilmente:

# sudo dpkg -i openfire_3.6.4_all.deb

Configuración

En primera instancia debemos seguir el intuitivo instalador des de la siguiente url:

http://localhost:9090

Por último deberemos realizar un restart del servidor para poder acceder al WebApp con el nuevo usuario administrador:

# /etc/init.d/openfire restart

Creación de usuarios

Cuando creamos dos usuarios y queremos que estos puedan verse y enviar mensajes debemos añadirlos al roster de cada uno. Es decir, el usuario u1 debe tener en su roster al usuario u2 y u2 debe tener en su roster a u1. De esta manera podrán verse. Luego los dos usuarios deberán tener subscription both, es decir, deben estar subscritos a from y to para poder enviar y recibir mensajes de los usuarios que tienen en su roster.

Para acceder a él tan solo debemos acceder mediante navegador web, después acceder a user/group y por último create user:

Crearemos dos usuarios adictoalainformatica1 y adictoalainformatica2 (originalidad antetodo). Despues deberemos entrar en la sección de cada usuario, en roster y por último clicar en Add Item:

Como podemos observar al usuario adictoalainformatica1 le añadimos al roster al usuario adictoalainformatica2 y debemos hacer lo respectivo para el usuario adictoalainformatica2 con adictoalainformatica1. Una vez echo esto deberemos cambiar el subscription para que los usuarios tengan completa «visibilidad» entre ellos. Debemos entrar en la sección del usuario adictoalainformatica1, luego en su roster donde veremos al usuario adictoalainformatica2. Bien, por último deberemos modificarlo y como vemos en la imagen debemos cambiar el subscription a both, en este caso los estamos haciendo para el usuario adictoalainformatica2 con respecto al usuario adictoalainformatica1 y deberemos hacerlo también a la inversa.

Ahora podríamos configurar dos clientes de xmpp (por ejemplo gajim y pidgin) con los dos usuarios y comprobar que pueden enviarse mensajes.

Observaciones

Ya hemos viso un servidor de xmpp, no es el que ofrece más opcionalidades pero para un desarrollo de nivel medio es más que suficiente. En grandes desarrollos donde tengamos una increíble cantidad de usuarios sería recomendable usar Ejabberd. Pero de todos modos con OpenFire tendremos un gran abanico de posibilidades y es mucho mas cómodo de administrar que Ejabberd. Un servidor XMPP puede ser útil tanto como para crear una red de mensajería a nivel interno de empresa como para montar un sistema de distribución de comandos. En el próximo post, ya cerrando con XMPP, mostraremos como crear un cliente con python capaz de conectarse, recibir y enviar estados y enviar y recibir mensajes.

Fuentes

Wikipedia – Openfire

Ruben

XMPP

Publicado en 26 enero, 2011 por

ruben Publicado en Sistemas — No hay comentarios ↓

Introducción

XMPP(Extensible Messaging and Presence Protocol) es un protocolo estándar y abierto que se basa en el intercambio de mensajes XML. Inicialment va ser concebut per implementar xarxes de missatgeria instantànea . Inicialmente fue concebido para implementar redes de mensajería instantánea. Quizás las herramientas más conocidas que usan el protocolo XMPP son Jabber, GTalk y las funciones de videoconferencia y audioconferencia de Google.

Funcionalidades

Redundancia.
Escalabilidad.
No hacen falta VPNs para compartir recursos dentro de una NAT.
Soporte SSL y Certificados
Backends donde se guardan los usuarios: MySQL, LDAP…
Extensible (usa lo que se llaman XEP – XMPP Extension Protocols)
BOSH permite usar XMPP sobre HTTP, lo que por diseño del protocolo XMPP sería un problema.

Protocolo

Vamos a desglosar, identificar y explicar las principales opciones que nos ofrece XMPP como protocolo.

JID: los nodos de una red XMPP identifican a través de este identificador, que es de la forma: user @ domain / resource (ejemplo: ruben@adictosalainformatica.com/linux ). Tratamiento de los JID:
- user@example.com – conocido como JID
- user@example.com/desktop – conocido como JID u full JID
Stanza: los mensajes XML que se intercambian entre un servidor XMPP y un cliente se llaman Stanzas. Hay tres tipos de Stanzas:
- Messages: transportan información entre nodos, los mensajes se pueden organizar en threads. Los hay de diferentes tipos:
  - normal
  - chat
  - groupchat
  - headline
  - error
- Presence: sirven para informar de la dipsonibilitat de un recurso (online / offline):
  - away
  - do not disturb
  - extended away
  - free for chat
- IQ Stanza (info query): similar a un HTTP GET / POST / PUT, sirve para pedir informaciones concretas a un nodo. Ideales para extender el protocolo. Por ejemplo, las IQ usan para saber qué recursos (usuarios) están conectados a un canal de chat. Los hay de tres tipos:
  - get: piden información (HTTP GET)
  - set: proveen información (HTTP POST / PUT)
  - result: devuelven información requerida o confirman que se ha aceptado un pedido ‘set’.
Extensibility: para que sea simple extender el protocolo, las Stanzas soportan namespaces y cualquier elemento XML de una stanza se puede usar como un payload, para transportar: XHTML tags, Atom feeds, XML-RPCs, etc.
Roster: lista de personas que participan en un evento.
Presence Subscription: los recursos de una red (a menudo los usuarios) pueden subscribirse a otros recursos (otros usuarios) para saber si están o no disponibles en cada momento.
Asincronismo: la gracia del XMPP respecto a otros protocolos como HTTP es que se trata de un protocolo asíncrono, o sea, que las conexiones se establecen durante mucho tiempo y en cualquier momento el servidor y / o el cliente pueden enviar y recibir Stanzas a través de este canal. Los protocolos HTTP establecen conexiones relativamente cortas donde a menudo sólo hay una petición y una respuesta después se cierra la conexión.

Jingle(add-on)

Jingle es una extensión al protocolo XMPP que permite la transferencia de información p2p. Este protocolo permite transmitir datos multimedia, habilitando servicios de VideoConferencia y de VoIP. Este protocolo fue diseñado inicialmente por Google junto con la XMPP Standards Foundation y liberado (bajo licencia similar a la de BSD).

Observaciones

Bien puede entenderse que este protocolo solo és útil para redes de mensajería instantànea, pero pensemos en sistemas de distribución de comandos. Resolvemos muchas incertidumbres facilmente, tenemos identificados los clientes, podemos enviar comandos a ciertos clientes y saber si estos clientes estan disponibles o no, por lo cual no habra un intento de envio esperando una respuesta de error simplemente no se envia, o si han recibido el comando correctamente, luego mediante respuesta del cliente podemos saber como ha ido la ejecución de cada comando por cada cliente.

Fuentes

Ruben

Android sdk en Ubuntu unknown device ????????????

Publicado en 8 enero, 2011 por

scuraki Publicado en Dispositivos, Programación, Sistemas — No hay comentarios ↓

Tras instalar android sdk , eclipse , actualizar etc , nos podemos encontrar con que el emulador funciona,
pero no podemos debugar en el dispositivo.

Debugar en el dispositivo , nos ayuda a crear aplicaciones para los sensores , y nos permite probarlo al mismo tiempo , como los sensores de nivel , gps , etc , sin el dispositivo sería muy difícil .

Problema en DDMS , dispositivo desconocido ????????????
No funciona el debug con el dispositivo.

/android-sdk/platform-tools$ ./adb devices devuelve :

List of devices attached
???????????? ??
unknown device ????????????
Fuente de la solución
En esta zona podemos ver la solución:

> 14:25 W/ddms: Unable to get frame buffer: device (????????????) request
> rejected: insufficient permissions for device
> ==
>
> I then checked
>
> ==
> $ ./adb devices
> List of devices attached
> ???????????? no permissions
> ==
>
> There appears to be a permission problem. I then wrote a
> `51-android.rules’ file (with chmod a+r) in /etc/udev/rules.d/, such that
>
> ==
> # cat 51-android.rules
> SUBSYSTEM==»usb», ATTRS{idVendor}==»0bb4″, ATTRS{idProduct}==»0c87″,
> MODE=»0666″
> ==
>
> (the idVendor is the HTC one). I then restarted udev, but to no avail:
> same problems. Any idea?
>
>
>

—
Merciadri Luca
See http://www.student.montefiore.ulg.ac.be/~merciadri/
I use PGP. If there is an incompatibility problem with your mail
client, please contact me.

Old 08-13-2010, 02:33 PM
Merciadri Luca

Default Android phone is not recognized by Android SDK, despite udev conf
Problem solved: restarting udev from CLI was not sufficient. I needed to
restart.

Resumiendo:
1:)-> crear el fichero /etc/udev/rules.d/51-android.rules :
$ sudo gedit /etc/udev/rules.d/51-android.rules
con el siguiente contenido:

SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", ATTRS{idProduct}=="0c87",
MODE="0666"

2:)-> darle permisos $ sudo chmod a+r /etc/udev/rules.d/51-android.rules
3:)-> reiniciar

Bueno , ya podemos utilizar el dispositivo , en la carpeta donde esté instalado adb ,
./adb devices , devuelve en mi caso

List of devices attached
HT0C4RX21596 device

ya podemos debugar , probamos creando un proyecto Android en eclipse , pulsamos el botón de debug y ya tenemos nuestro hello world …. que tanto deseábamos.

PHP ON COUCH

Publicado en 5 enero, 2011 por

ruben Publicado en Programación — 1 comentario ↓

Introducción

Php On Couch es una librería en php para atacar bases de datos, en adelante bbdd, de CouchDB . Por el uso que le he dado he podido comprobar su estabilidad y ademas se actualiza regularmente, lo cual es de agradecer. Cabe decir también que esta bajo licencia GPL.

En este ejemplo veremos como conectar a una base de datos y extraer la información de un documento, obviamente esta librería ofrece muchísimas más funcionalidades, pero este post no pretende ser una explicación de cada una de ellas. Pretende mostrar una utilización práctica de la librería, en él se creará un gráfico con Google Chart Api a partir de datos guardados en CouchDB.

Estructura

Dispondremos de los siguiente ficheros:

index.php: archivo principal.
couch.php: clase que utilizaremos para acceder a CouchDB.
config.php: archivo de configuración.

Crearemos una base de datos con las siguientes características:

El nombre de la base de datos será navigator.
El id del documento al que accederemos tendrá el siguiente id: 1qaz.
El documento almacenara un valor para los siguientes tags: ie, firefox y chrome.

Debemos descargarnos la librería Php On CouchDB y estructurar el proyecto conforme la la carpeta lib, de dicha librería, se encuentre en el mismo nivel que los archivos PHP.

index.php

Este archivo incluirá la la clase couch.php, la instanciará y llamará al método chart para que este le retorne el gráfico.

/**
 * User: rmiguel
 * Date: 22/07/2015
 * Time: 20:00
 */

require_once "CouchWrapper.php";

print "

Couchdb Test

«; $con = new CouchWrapper(); print $con->chart(«600×200″,»1qaz»);

config.php

Este archivo es el típico utilizado para parametrizar las WebApp que tienen acceso a bbdd, no comentare el archivo por su simpleza y los descriptivos nombres de las variables. Dado que esto es un ejemplo, me permito la licencia de utilizar variables globales, no cabe decir que en una aplicación de uso está sería una mala implementación de uso para un archivo de configuración dada la información que contiene. Personalmente yo creo un xml que parseo con un método privado en la clase, el cual guarda el valor de los tags en variables privadas. De esta manera aseguramos que este método y las variables son usadas únicamente por la clase protegiéndolas dada la importancia de su valor.

/**
 * User: rmiguel
 * Date: 22/07/2015
 * Time: 20:00
 */
//Couch_db config
$COUCHDB_HOST = "127.0.0.1";
$COUCHDB_PORT = "5984";
$COUCHDB_TABLE = "navigator";

couch.php

Este archivo es el que contiene la clase _couch. Primero incluimos las dependencias (de la librería y el archivo de configuración) .

A continuación explicaremos la estructura de la classe:

Variables

$client será donde se guardará la instancia cliente que ataca a la bbdd.
$couchdsn será la url y el puerto (http://127.0.0.1:5894)
$couch_db será la base de datos (navigator)

Métodos

_couch -> es el constructor en él se realizará la conexión a la bbdd.
get_doc($id) -> retornara una variable con la estructura del documento correspondiente al id que se le pasa por parámetro.
chart -> retornará una url del tipo pie chart que atacara a google chart api para crear un gráfico en función del id de documento y la resolución que se especifique.

/**
 * User: rmiguel
 * Date: 22/07/2015
 * Time: 20:00
 */
//-----------------------
require_once "lib/couch.php";
require_once "lib/couchClient.php";
require_once "lib/couchDocument.php";
require_once "config.php";
//-----------------------------------
class CouchWrapper {
    public $client;
    public $couch_dns;
    public $couch_db;
    /**
     * Constructor
     */
    function __construct(){
        $couch_dsn ="".$GLOBALS['COUCHDB_HOST'].":".$GLOBALS['COUCHDB_PORT'];
        $couch_db = $GLOBALS['COUCHDB_TABLE'];
        try{
            $this->client = new couchClient($couch_dsn,$couch_db);
        } catch (Exception $e) {
            echo "Error:".$e->getMessage()." (errcode=".$e->getCode().")\n";
        }
    }
    /**
     * @param $id
     * @return document values
     */
    function get_doc($id){
        try{
            $doc = $this->client->getDoc($id);
        } catch (Exception $e) {
            if ( $e->code() == 404 ) {
                echo "Document \"some_doc\" not found\n";
            } else {
                echo "Something weird happened: ".$e->getMessage()." (errcode=".$e->getCode().")\n";
            }
            exit(1);
        }
        return $doc;
    }
    /**
     * @param $resolution
     * @param $id_document
     * @return chart image tag
     */
    function chart($resolution,$id_document){
        $doc = $this->get_doc($id_document);
        $green = $doc->ie;
        $orange = $doc->firefox;
        $yellow = $doc->chrome;
        $chart = "

«; return $chart; } }

Resultado

Una vez ejecutemos en nuestro servidor web index.php deberíamos obtener este resultado si todo ha funcionado correctamente:

Observaciones

Bien con este post doy por finalizada la breve introducción al mundo de las bbdd NoSql, espero y deseo que hayan sido de ayuda.

Posts relacionados

-> NoSql

-> NoSql – CouchDB

Código fuente en GitHub

PHPonCouch GitHub

Fuentes

Ruben

Introducción a los mundos virtuales

Publicado en 20 octubre, 2010 por

scuraki Publicado en Mundos Virtuales — No hay comentarios ↓

Los Mundos Virtuales son mundos alternativos , como ya sabemos , pero sabemos muy bien que hacer con ellos ¿no? , la mayoría son juegos como Los Sims , como World of Warcraft , en los que pasamos el tiempo libre , horas y horas , pasando miles de aventuras .

Tras la aparición de Software como Second Life , los mundos virtuales nos permiten más cosas , NO SON JUEGOS , nos permiten crear objetos (no solo algunos predeterminados) , socializarnos por chat , web , crear y utilizar espacios para difundir información a visitantes desconocidos , nos permiten crear vídeos , aplicaciones en un espacio en 3d con cierta agilidad con lenguajes como LSL.

Es muy utilizado por ejemplo para conferencias virtuales , haciendo un streaming de vídeo , o en materias de educación para amenizar los estudios de los jóvenes , haciendo por ejemplo clases virtuales de física , entre otras materias.

¿Como empezar , como iniciarse? , Pues la mejor manera es utilizar un mundo virtual ya existente como usuario , crear un avatar , y probarlo.

¿Que es un avatar? , Pues el avatar representa a nuestro usuario dentro del mundo , normalmente podemos definir algunos aspectos de su sexo ,ropas , color , etc , suele estar representado como un humanoide , pero puede ser un objeto.
Con este avatar nos desplazamos por el mundo en 3d , donde podemos andar , correr , saltar ,bailar, volar , y la cámara de nuestro programa seguirá sus movimientos a una distancia prudencial.

Normalmente al entrar en un mundo virtual por primera vez , se aparece en una especie de recepción , que nos da un poco la bienvenida hasta que definimos una destino y ya nos disgregamos por el mundo virtual.

No está de más recordar que según donde entréis pueden haber contenidos de pago.
Second Life por ejemplo utiliza su propia moneda y para conseguirla se ha de pagar con dinero real.
También se puede conseguir de los demás , si eres bueno puedes crear objetos y llegar a venderlos , por ejemplo ropa ,pulseras , vehículos , etc.

Bueno , antes de empezar con los objetos , empezaremos por explicar que nos podemos encontrar , donde podemos ir , etc.

Normalmente el programa que utilizamos para conectar al mundo , incluye un buscador , con un mapa.
Si buscamos por una ciudad , empresa , cualquier cosa , nos devolverá un listado con los resultados de la búsqueda , y nos permitirá trasportarnos al lugar elegido.
En el mapa podemos ver un cuadrado , que representa el mar con unos puntos , que nos informan de donde están y su nombre. También podemos apreciar unas coordenadas que podemos utilizar para transportarnos.

Una vez que llegamos a nuestro destino , no suele haber 2 iguales , aquí ya va la imaginación del propietario del lugar , o de sus ayudantes.

En un mundo virtual los contenidos los crea alguien por supuesto , en Second Life se pueden ver muchos ejemplos , pero de donde sale? , pues para que exista un mundo tiene que haber un servidor por lo menos , que contenga la información de nuestro avatar y nos permita acceder al contenido de forma virtual.

En la web de Second Life podeis consultar las tarifas de lo que cuesta una parcela de tierra.
Podemos instalar nuestro propio mundo virtual con OpenSim , donde podemos crear a nuestro antojo , sin coste alguno , o utilizar servidores gratuitos que hay unos cuantos , ya haré un post explicándolo.

Bueno las parcelas tienen un propietario , eso lo hemos dejado claro , este propietario , puede crear objetos de todo tipo , vehículos , ropas , etc , los cuales podemos ver , tocar , algunos los podemos copiar , vender , etc .

¿Y los demás, no pueden crear objetos? , Existen algunas zonas normalmente llamadas Sandbox , donde el propietario permite a otros usuarios crear sus propios objetos , si buscáis sandbox en el buscador seguramente encontréis lugares donde poder construir.

Los objetos que creéis son de vuestra propiedad , podéis copiarlos , programarlos , compartirlos , venderlos , en las propiedades del objeto , podéis asignarles los permisos que deseéis.

Construyendo

Del mismo modo podemos asignar permisos a nuestros scripts de programación.

Bueno hasta aquí la introducción a los mundos virtuales , más adelante explicaremos diferentes servidores , clientes a utilizar para conectarse , como crear objetos con blender y pasarlos al mundo ,exportarlos , etc.

Tutorial Javafx + Inkscape + Netbeans

Publicado en 17 octubre, 2010 por

admin Publicado en 2D, Programación — No hay comentarios ↓

Primer tutorial Javafx en adictosalainformatica.com.

JavaFX es un lenguaje de programación de scripts desarrollado por SUN , que nos permite hacer aplicaciones para móviles , televisores , aplicaciones de escritorio (ventana) , y Applets (incrustados en páginas web).

Inkscape (Programa de diseño gráfico vectorial) , nos permite crear un gráfico y exportarlo como código javafx .

Este será el primero de una serie de tutoriales JavaFX , y el primero también de Inkscape.

Utilizaremos Netbeans 6.9 con JavaFX instalado .

Primero crearemos un proyecto en Netbeans en File/New Project/JavaFX/JavaFX Script Application.
Le ponemos el nombre que queramos
Esto nos genera un proyecto con una carpeta src , un fichero main.fx , lo modificamos para que quede así:

Stage {
title: "Adictos a la informática" //cabezera de la aplicación
scene: Scene {
width: 705
height:500
content: [
Text {//caja de texto , opcional
font : Font {
size : 16
}
effect: Reflection {//Opcional , para aplicarle reflejo al texto
fraction: 0.75
topOffset: 0.0
topOpacity: 0.5
bottomOpacity: 0.0
}
x: 10
y: 10
content: "Scuraki" //texto Poned lo que querais , opcional
}
]
}
}

Podemos probar como se ve pulsando el botón de run o el de debug.

Pasamos a inkscape , y realizamos un gráfico .
En mi caso he dibujado un pato en 1,5 minutos , he trazado una curva,
después pulsando el botón de convertir las lineas del objeto seleccionado en trayectos ,
esto nos permite seleccionar los nodo y crear una figura .Es posible que tengamos demasiados nodos y
nos sea difícil , si dejamos pocos nodos nos será más fácil , seleccionamos los que queremos borrar y pulsamos la tecla Supr.

Pantallazo-pato.svg - Inkscape

Para colorear nuestro dibujo en el menú objeto abrimos la opción relleno y borde.
Esto nos abre el cuadro de colores , donde nos permite cambiar el color , utilizar un degradado lineal , un degradado circular , o un patrón .Seleccionamos el degradado lineal .

Pantallazo-pato.svg - Inkscape-1

Si queremos podemos girar el degradado como mejor nos quede , en el modo de edición de nodos, en el degradado se ven 2 nodos enlazados con una línea , si movemos los nodos movemos el degradado.

Pantallazo-pato.svg - Inkscape-3

Bueno , tenemos una figura en mi caso es como un pato , le pondré un ala , para que de mejor impresión, dibujo una curva y pongo el degradado que he utilizado con el pato , para ahorrar y la situo en el pato , si es necesario se puede voltear girar , rotar .

Pantallazo-pato.svg - Inkscape-6

Para un mejor seguimiento de las partes de nuestro diseño , con botón derecho en el pato le damos a propiedades , y le llamamos pato , hacemos lo propio con el ala , y la llamamos ala.

Pantallazo-Propiedades del objeto

Seleccionamos los 2 objetos y en el menú objeto seleccionamos agrupar (Alt + G también agrupa).

Bueno , ya tenemos un pato agrupado , ahora lo vamos a convertir en código JavaFX , guardamos el documento como svg de inkscape para no perderlo, y volvemos a guardar , pero esta vez lo guardaremos como fichero .fx (desplegar el combo y seleccionar .fx de javafx) , en la carpeta src de nuestro proyecto de Netbeans que hemos creado antes.

Volvemos a Netbeans , y veremos nuestro fichero fx , en micaso pato.fx.
Editamos el fichero pato.fx , y observamos que hay una clase pato que extiende de CustomNode con un método para cada parte de nuestro dibujo , el pato , el ala , los degradados que hemos creado , un un grupo .

Pantallazo-JavaFXApplication4 - NetBeans IDE 6.9 Beta-1

También hay un método que se llama create que es el encargado de devolver el contenido , en el group , le aplicaremos un efecto de reflejo , para que quede más bello.

Pantallazo-JavaFXApplication4 - NetBeans IDE 6.9 Beta-2

Group { //grupo
content: [
pato(),//dibuja el pato
path3612(),//esto varia segun el diseño
ala(),//dibuja el ala
] // content
transforms: Translate { x : 0, y : 650 } //posicionamos el grupo en la escena , viene con valores
effect: Reflection { //efecto de reflejo
fraction: 0.75
topOffset: 0.0
topOpacity: 0.5
bottomOpacity: 0.0
}
} // Group

Ahora vamos al fichero main.fx , donde llamaremos a nuestro pato para que se pinte por pantalla.
Creamos un objeto de tipo Node , var pato:Node; , y le asignamos el valor creando un objeto pato , pato=new pato(); .

Añadimos el pato a la escena
Ejecutamos el proyecto , y graduamos el ancho de la escena en main.fx Scene , y la posición del gráfico donde os comenté arriba.

En mi caso tengo también 2 gráficos , me quedó así:

package javafxapplication4;

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.text.Text;
import javafx.scene.text.Font;
import javafx.scene.Node;
import javafx.scene.effect.Reflection;

/**
* @author scuraki
*/
var adicto:Node;
adicto=new adictosalainformatica();
var patito:Node;
patito=new pato();
Stage {
title: «Adictos a la informática»

scene: Scene {
width: 705
height:500
content: [
Text {
font : Font {
size : 10
}
effect: Reflection {
fraction: 0.75
topOffset: 0.0
topOpacity: 0.5
bottomOpacity: 0.0
}
x: 10
y: 10
content: «Scuraki»
},adicto,patito //añade los gráficos vectoriales
]
}
}

Pantallazo-Adictos a la informática

Bueno hasta aquí el tutorial , se puede apreciar algunos errores en el Path del ala y en la posición del degradado , pero puede ser útil ¿no os parece? , espero que os haya resultado interesante , hasta la próxima.

NoSql – CouchDB

Publicado en 15 octubre, 2010 por

ruben Publicado en Sistemas — 1 comentario ↓

Introducción

CouchDB es una BBDD NoSql (si tienes dudas sobre NoSql es recomendable visitar el siguiente post Bases de Datos NoSql) de documentos en formato JSON. Dichos documentos se referencian por una clave única _id a los cuales se puede acceder por HTTP y gestionar mediante javascript. Esta programado Erlang, un lenguaje de programación muy robusto, fiable y multiplataforma, que se ejecuta sobre una máquina virtual de alto rendimiento.

Claves y revisiones

Ambos campos tienen que ser únicos, no pueden estar duplicados entre otros documentos en la misma base de datos.

_id (clave): es el identificador único e inequivoco del documento (DocID)
_rev(revisión): es un identificador del documento para tratar su historico. Es decir, de cada documento se guardan revisiones para poder acceder a anteriores versiones de dicho documento.

Revisiones

Cada vez que modificamos un documento en CouchDB se crea una nueva revisión de este. En principo esto nos permite acceder a anteriores versiones del documento, pero puede llegar a ser un lastre. Por esa razón podemos compactar el documento, al hacerlo tansolo quedará disponible la última revisión.

En CouchDB podemos hacer consultas directas por identificador y por revisión, podemos obtener todas las revisiones activas de un documento (si existieran) y podríamos consultar información sobre las mismas.

A partir de la versión v 0.11 se puede especificar el número de revisiones:

curl -X PUT -d "200" http://localhost:5984/test/_revs_limit

Para compactar la base de datos y así eliminar las revisiones antiguas:

curl -X POST http://localhost:5984/nombre_base_de_datos/_compact

Vistas

CouchDB permite la creación de vistas, que son el mecanismo que permite la combinación de documentos para retornar valores de varios documentos, es decir, CouchDB permite la realización de las operaciones JOIN típicas de SQL.

Replicación

La replicación entrebases de datos nos permite duplicar datos con la seguridad de no perderlos. Hay que tener en cuenta que al guardar revisiones de los documentos siempre dispondremos de todas las revisiones. Es decir, pongamos que en tenemos una base de datos bbdd1 y otra bbdd2 y cambiamos un documento común doc1, después de la replicación tendremos las revisiones de los documentos anteriores y las revisiones de los nuevos documentos en las dos bases de datos. Es nos asegura consistente persistencia de datos.

Para habilitar la replicación activa entre dos bases de datos (cada vez que hay un cambio automaticamente las bases de datos se replican) tansolo debemos ejecutar el siguiente comando:

curl -X POST http://localhost:5984/_replicate -d '{"source":"db", "target":"db-replica", "continuous":true}'

Resolución de conflictos

En CouchDB la detección y resolución de conflictos esta automatizada. En el caso de que un documento se intente actualizar en distintos nodos se guardaran las distintas versiones y poniendo como la versión más reciente la ganadora. Para solventar conflictos, CouchDB permite gestionar las versiones, pudiendo borrar veriones erroneas o reordenarlas por fecha.

Instalación

Tan simple como ejecutar en la consola:

sudo apt-get install couchdb

Luego podemos comprobar en un navegador si CouchDB ha arrancado correctamentte accediendo a la siguiente

url http://localhost:5984/

, en caso de que todo funcione correctamente recibiremos una respuesta web similar a esta dependiendo de la versión de CouchDB:

{"couchdb":"Welcome","version":"0.10.0"}

Comandos básicos mediante curl

En primera instancia deberemos instalar curl:

 sudo apt-get install curl

Para visualizar todas las bases de datos:

curl http://localhost:5984/_all_dbs

Crear una base de datos:

curl -X PUT http://localhost:5984/test

Crear un nuevo documento:

curl -X PUT http://localhost:5984/test/8765rftded6c29495e54cc05947f18c8af -d '{"SO":"Linux","Distro":"Debian"}'

Borrar la base de datos:

curl -X DELETE http://localhost:5984/test

Futon

Futon es una aplicativo web muy intuitivo y fácil de usar, por lo que no explicaré como realizar las operaciones antes descritas con curl , para gestionar bases de datos y sus documentos en CouchDB.

Para acceder a él tansolo debemos acceder mediante navegador web a la siguiente url:

http://localhost:5984/_utils/

Observaciones

Llegados a este punto ya tenemos un concepto básico sobre las bases de datos NoSql y la utilización de un gestor, CouchDB. El próximo post sobre este tema estará en el apartado de programación, donde se expondrá un ejemplo de acceso a CouchDB mediante PHP.

Fuentes

Ruben

Bases de Datos NoSql

Publicado en 14 octubre, 2010 por

ruben Publicado en Sistemas — 1 comentario ↓

Introducción

Las Bases de Datos ,en adelante BBDD, NoSQL son bases de datos no relacionales u orientadas a documentos y que normalmente carecen de esquemas fijos de tablas.

Las BBDD NoSql se orientan a documentos, no en tablas con campos uniformes para cada fila o registro. Cada documento es almacenado de forma que tenga ciertas características, cualquier número o tipo de campos pueden ser añadidos a un documento, e incluso contener varios tipos de datos.

Su mayor ventaja es que el escalado horizontal es extremadamente sencillo, es decir, se pueden añadir nodos sin temor a que esto afecte significativamente al rendimiento puesto que el almacenamiento no esta sujeto a toda una estructuración de BBDD relacional. Normalmente el documento consta de dos campos:

id_ que será el único identificador
doc: documento donde se guarda toda la información.

Ejemplo práctico

Comparación BBDD NoSql – SQL

NoSql:

Clave	Documento
1	Nombre: PlayStation; Compañia: Sony; Color: Negro;
2	Nombre: Wii; Compañia: Nintendo; Color: Blanco; HD: no;
3	Nombre: Xbox; Compañia: microsoft;

Sql:

Clave	Nombre	Compañia	Color	HD
1	PlayStation	Sony	Negra
2	Wii	Nintendo	Blanco	No
3	Xbox

Podemos ver que en la BBDD NoSql los campos vacíos no se añaden y que se pueden añadir campos concretos a documentos concretos, sin tener que aumentar el número de columnas. Por lo que al manejar la información en NoSql no estaremos escalando campos vacíos o NULL y podremos modificar una fila a nuestro antojo sin que esto tenga que afectar a toda la estructura de la tabla.

Aplicaciones NoSQL más populares:

CouchDB
MongoDB
Cassandra

Observaciones

En el próximo post profundizaré en CouchDB y posteriormente en el apartado de Programación postearé un ejemplo de como acceder a couchDB con PHP. Cabe destacar que CouchDB se ha echo muy popular tanto por su potencia como por el hecho de haber sido apadrinado por Apache.

-> NoSql – CouchDB

Fuentes:

http://en.wikipedia.org/wiki/Document-oriented_database
http://en.wikipedia.org/wiki/NoSQL

Ruben.

D-Bus – Sistema de comunicaciones entre procesos.

Publicado en 13 octubre, 2010 por

ruben Publicado en Programación — No hay comentarios ↓

El objetivo es mostrar, utilizando Python, un ejemplo de como realizar un test básico de comunicación D-Bus.

Introducción

D-Bus (Desktop Bus) es un sistema de comunicación de procesos. D-Bus es desarrollado como parte del proyecto freedesktop.org y en entornos linux es ampliamente utilizado.

D-Bus consiste en tres capas:

La biblioteca libdbus, que permite a dos aplicaciones conectarse e intercambiar mensajes.
Un demonio ejecutable, construido sobre libdbus, al cual pueden conectarse varias aplicaciones. El demonio expande el mensaje enviándolo a una o más aplicaciones.
Wrappers para su uso.

D-Bus es utilizado en:

La comunicación entre aplicaciones de escritorio en la misma sesión.
La comunicación entre el S.O. y la sesión de escritorio.

Ejemplo

Introducción

El ejemplo consta de dos ficheros. Sender.py y Receptor.py los dos alojados en </home/ruben/Documents/dbus>, en cada caso se debe adecuar a la ruta en la cual guardemos los ficheros python.

Receptor.py:

#!/usr/bin/env python
#--encoding: UTF-8--

"""
entra en un loop esperando senales emitidas a:
dbus_interface = ruben.prova
object_path = "/home/ruben/Documents/dbus"
con el nombre de senal: 'estat'
cuando se recibe la senal la mostramos
"""

import gobject, dbus, dbus.mainloop.glib

def mostra(m):
 print m

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SessionBus()
bus.add_signal_receiver(
 mostra,
 path="/home/ruben/Documents/dbus", 
 dbus_interface="ruben.prova", 
 signal_name = "estat" 
 )

loop = gobject.MainLoop()

loop.run()

Sender.py:

#!/usr/bin/env python
#--encoding: UTF-8--

"""
Emite una senal a dbus, al bus 'session' al destino:
 dbus_interface = ruben.prova 
 object_path = "/home/ruben/Documents/dbus"
con el nombre de senal: 'estat'
"""

import gobject
import dbus
from dbus.service import signal,Object
import dbus.mainloop.glib

class EmetSenyal(Object):

 def __init__(self, conn, object_path='/'):
 Object.__init__(self, conn, object_path)

 
 @signal('ruben.prova') 
 def estat(self,m):
 global loop
 print("sended signal: %s" % m)
 gobject.timeout_add(2000, loop.quit)


dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
loop = gobject.MainLoop()
bus = dbus.SessionBus()
o = EmetSenyal(bus,object_path='/home/ruben/Documents/dbus')
o.estat('Tux')
loop.run()

Monitoring

En un terminal ejecutamos:

 python receptor.py

Y en otro vamos ejecutando:

python sender.py

Finalmente en un terminal aparte ejecutaremos:

dbus-monitor

de esta manera podremos observar como sender.py envia la señal cada vez que lo ejecutamos.

Observación

En si el ejemplo carece de utilidad, solo pretende ser un ejemplo de iniciación. Un uso mas adecuado podría ser el paso de información, por ejemplo, usarlo para el almacenamiento de log de módulos de un aplicativo. Es decir, imaginemos que tenemos tres módulos Mod1, Mod2 y Mod3 conectados por D-Bus y un cuarto modulo de log. Cuando cualquiera de los tres módulos envía una señal de log de info o debug los demás lo ignoran y tansolo el modulo log se encarga de procesar el log y hacer lo que deba con el (almacenamiento en disco duro, envio por email…), pero en caso de que sea una senyal de log_error(moduele_name,error_name) los demas modulos recogen la senyal y sabran que han perdido una funcionalidad de dicho módulo, hasta que no se reciba una nueva señal de inicio de Mod1. De esta manera tendremos integrado un sistema de log para los diferentes módulos del aplicativo y a su vez un sistema de alertas entre estos.

Fuentes

http://es.wikipedia.org/wiki/D-Bus

Código en GitHub

DBus code example

Ruben.

Pelo en blender Primer tutorial

Publicado en 2 octubre, 2010 por

scuraki Publicado en 3D — No hay comentarios ↓

Primer tutorial de blender Antes de nada Blender es un programa de modelado , animación , etc en 3D. Blender es gratuito , opensource . Para descargar Blender , visitad la página de descargas de Blender. En este tutorial se utilizará la versión 2.5 Beta para Linux. Empezaremos con una introducción a las teclas y al entorno. Al iniciar Blender nos sale por defecto un cubo , una luz y una cámara. El objeto seleccionado es el cubo , que está iluminado. Si pulsamos las teclas Ctrl + Alt y movemos la rueda del ratón veremos que la vista gira alrededor del cubo . Si pulsamos Shift y la rueda del ratón se mueve la vista en sentido vertical . Si pulsamos Ctrl y la rueda del ratón se mueve la vista en sentido horizontal. Si pulsamos con botón derecho en un objeto , se selecciona el objeto pulsado. En este enlace: http://blender.gulo.org/ encontrareis tutoriales para iniciarse a Blender , versión 2.4 y en este la versión 2.5. Bueno vamos con el tutorial. -Creamos un nuevo documento , en File/New. -Eliminamos el cubo pulsando la tecla Supr. -Añadimos un Metaball , en Add/Metaball/Metaball , este será el primero de varios. -Añadimos otro Metaball , este no se vé , desplazamos el objeto seleccionado pulsando las flechas de movimiento , hacia arriba , y observamos que los 2 están unidos por una misteriosa fuerza , que si lo alejamos demasiado se separan. Éste es el motivo de utilizar Metaball , en vez de esferas normales.

Uso de Metaball

-Hacemos más grande (escalar) el Metaball seleccionado , dando forma a nuestro objeto. -Así añadiremos los Metaball necesarios para tener la figura que deseamos , en este caso una cabeza , uno para cada oreja , los ojos , la boca.

Escalando

-Una vez tengamos una figura (básica) que nos convenza , transformaremos el metaball en un Mesh (Masa), para convertirlo en un objeto con propiedades . Pulsamos Alt + c , y seleccionamos la Opción Mesh from Curve/Meta/… -Ya tenemos un objeto Mesh , con todas sus propiedades , ya podemos asignarle un Material , esculpir la figura , editar los vértices , etc . Ahora vamos a crear 2 materiales , uno será el de la cara y otro será el del pelo. El Material puede ser transparente , tiene 2 colores difuse (color) y especular (color al reflejar), puede reflejar la luz (Mirror) ,etc. -Para crear Pelo vamos a la opción de Partículas , añadimos una , de tipo Hair. Esto nos genera pelo en todas las partes del objeto , para evitar esto , y que solo salga por la parte que nos interesa , osea arriba y detras de la cara, tendremos que crear un grupo de vértices .Vamos a edit mode (o pulsamos Tab) , pulsamos la tecla a, para seleccionar o deseleccionar todos , y pulsando la tecla b nos permite seleccionar creando un rectángulo. Una vez seleccionado pulsamos Ctrl + g para crear un nuevo grupo. En la pestaña de partículas vamos a la opción vertexgroups y en el primero , seleccionamos el grupo creado antes (si es el primero se llama group , sino group0001 , etc).

Uso de Particle Mode

-Ya tenemos el pelo en la zona que queremos.Ahora le asignamos el material 2 ,que es el segundo de la lista de materiales , para que no sea del mismo color que la cara .

Uso de las propiedades de partículas

-Una vez tenemos el pelo del color que tengamos puede que nos interese peinar el pelo, si peinar no me he equivocado , entramo en el modo Particle Mode , a la izquierda en el menú de Brush (brocha) , por defecto arriba está seleccionado none , seleccionamos comb para poder modificar y vamos peinando nuestra figura. -Más o menos tenemos nuestra figura creada , ahora falta renderizar , ¿eso que es? , pués es obtener imágenes de cada paso (frame) , a partir de lo que ve la cámara. En nuestro caso tenemos solo 1 imagen , ya explicaré como crear animaciones ,sencillas. Si pulsamos Ctrl + Izq de los cursores de teclado o Ctrl + Dcha , podemos cambiar la perspectiva de blender , hay una perspectiva de animación , otra de juegos , y normalmente hay una de cámara. También podemos ver lo que ve la cámara (recordad que es un objeto y la podemos mover , rotar e incluso la podemos animar) pulsando Numpad0 , o en el menú view/Camera. Si seleccionamos la perspectiva de camera podemos ajustar el objeto que hemos creado al rectángulo que ve la cámara , moviendo con las flechas de desplazamiento . Podemos ver el resultado en el menú Render/Render Image , o pulsando F12.

Pelo coloreado y peinado

-Por defecto tenemos una luz , las luces se pueden copiar , modificar el color de la luz , mover , rotar. Como cualquier otro objeto , podemos animar la luz , etc . Para este ejemplo he utilizado la luz de tipo Sun (Sol) , pero podeis elegir la que querais , en el panel Light , estando la luz seleccionada. Por último , un enlace a como crear pelo artístico con curvas y la herramienta de esculpir : http://simpatiaporblender.blogspot.com/2010/01/interesante-forma-para-modela-cabellos.html No está de más explicar que se puede combinar el pelo creado con el sistema de partículas con pelo creado con el sistema de curvas ,como explica el tutorial anterior , puede dar resultados muy buenos , por ejemplo para crear una pulsera. y hasta aquí nuestro primer tutorial de blender .

XMPP – OpenFire

XMPP

Android sdk en Ubuntu unknown device ????????????

PHP ON COUCH

Introducción a los mundos virtuales

Tutorial Javafx + Inkscape + Netbeans

NoSql – CouchDB

Bases de Datos NoSql

D-Bus – Sistema de comunicaciones entre procesos.

Pelo en blender Primer tutorial

Adictos a:

Sitios de interés

Últimas Noticias

Actividad