No hace mucho escribí sobre la creación de un aplicación de chat que utiliza Angular 2 para el front-end y Golang para el back-end. La comunicación de mensajes entre ambos era posible gracias a los websockets. En este ejemplo, cualquier número de clientes Angular 2 podían conectarse a la aplicación Golang y comunicarse entre sí, pero los nuevos clientes no podían ver los mensajes anteriores. Esto se debe a que los datos no se guardaban después de ser enviados.
Vamos a ampliar la aplicación Golang que se creó anteriormente e incluir Couchbase para que los mensajes se guarden una vez enviados y se carguen cuando se conecten nuevos clientes.
Requisitos
Hay algunos requisitos para poner en marcha este proyecto. Son los siguientes:
- Couchbase Server 4.1+.
- Golang 1.7+.
- Un cliente y un servidor de chat en funcionamiento como se ve en el tutorial anterior.
Es muy importante que tengas el servidor de chat funcionando ya que mucho de lo que veremos será una revisita a lo hecho en la guía anterior. Incluir una base de datos Couchbase NoSQL será trivial, pero Couchbase con soporte para consultas N1QL debe estar ya instalado.
Creación de un bucket de servidor Couchbase y adición de un índice
Este proyecto requerirá la creación de al menos un bucket en Couchbase. Este bucket contendrá todos los datos de los mensajes enviados desde y hacia el servidor de chat Golang. Los datos almacenados serán algo parecido a esto:
|
1 2 3 4 5 |
{ "sender": "62f142ce-7308-4dae-9eb0-3ae61d363c22", "content": "Hey there Nic Raboy!", "timestamp": 1482174735 } |
Puede optar por utilizar Couchbase por defecto o crear uno nuevo. Voy a utilizar un cubo llamado ejemplo en este proyecto.
Dado que vamos a realizar consultas, necesitamos definir al menos un índice que pueda ser utilizado en nuestro bucket. Este índice puede crearse usando Couchbase Query Workbench o Couchbase Shell (CBQ). Usando una de estas herramientas, ejecuta lo siguiente:
|
1 |
CREATE PRIMARY INDEX ON `example` USING GSI; |
Con el índice creado, la aplicación puede modificarse para incluir almacenamiento NoSQL.
Establecer una conexión con el servidor Couchbase
Antes de que podamos empezar a guardar datos en Couchbase, se debe establecer una conexión desde nuestra aplicación Go. Si has seguido las instrucciones guía anteriorsu aplicación Go podría encontrarse en una ruta similar a $GOPATH/src/github.com/nraboy/realtime-chat/main.go.
Antes de abrir tu archivo de código fuente, necesitas instalar el SDK de Golang para Couchbase. Se puede instalar ejecutando:
|
1 |
go get github.com/couchbase/gocb |
Con el SDK de Couchbase instalado, abra $GOPATH/src/github.com/nraboy/realtime-chat/main.go e incluya la siguiente línea fuera de cualquier función:
|
1 |
var bucket *gocb.Bucket |
Hemos incluido la variable fuera de cualquier función porque queremos que sea global a nuestra aplicación, no local a una función en particular.
Dentro de la principal antes de la goroutine de nuestro gestor de clientes, queremos establecer una conexión con el cluster y abrir un bucket en particular. Esto se puede hacer de la siguiente manera:
|
1 2 |
cluster, _ := gocb.Connect("couchbase://localhost") bucket, _ = cluster.OpenBucket("example", "") |
En el escenario anterior me he conectado a mi nodo que se ejecuta localmente y he abierto el archivo ejemplo creado anteriormente.
En este punto Couchbase está listo para ser utilizado y podemos centrarnos en nuestro modelo de datos.
Definición del modelo de datos JSON de Couchbase
Anteriormente vimos el modelo de datos JSON propuesto, pero necesitamos hacerlo posible a través de Golang. Esto se hace mediante el uso de una estructura de datos Golang.
Cerca de las otras estructuras de datos existentes, se incluyen las siguientes:
|
1 2 3 4 5 6 |
type Message struct { Sender string `json:"sender,omitempty"` Recipient string `json:"recipient,omitempty"` Content string `json:"content,omitempty"` Timestamp int64 `json:"timestamp,omitempty"` } |
Lo anterior Mensaje tiene propiedades asignadas a elementos JSON. Un elemento que no vamos a utilizar, pero que tendría sentido tener es el elemento Destinatario. Nunca se sabe si más adelante querrá enviar mensajes a clientes concretos.
Couchbase puede trabajar directamente con el Mensaje para guardar y leer datos. Para enviarlo a través de un websocket, se puede convertir en JSON.
Guardar y cargar mensajes con Couchbase
Esto nos lleva a guardar y cargar los datos. Tenemos la base de datos configurada con una conexión establecida. Tenemos nuestro modelo de datos. Ahora vamos a ponerlo en uso.
Para simplificar vamos a mantener cada documento id único. Esto se puede hacer a través de una biblioteca UUID que se puede instalar a través de la línea de comandos de esta manera:
|
1 |
go get github.com/satori/go.uuid |
Dentro de la aplicación añada un saveMessage como el siguiente:
|
1 2 3 |
func saveMessage(message *Message) { bucket.Upsert(uuid.NewV4().String(), message, 0) } |
Observe que estamos aceptando un Mensajegenerando una nueva clave de documento e introduciéndola en la base de datos. Esto significa que cada mensaje se almacenará como su propio documento.
¿Qué tal cargar los datos cuando se establece una conexión?
|
1 2 3 4 5 6 7 8 |
func (manager *ClientManager) loadMessages(client *Client) { query := gocb.NewN1qlQuery("SELECT `example`.* FROM `example` ORDER BY timestamp") rows, _ := bucket.ExecuteN1qlQuery(query, nil) var row Message var jsonMessage []byte for rows.Next(&row) { jsonMessage, _ = json.Marshal(row) client.send |
En el loadMessages aceptamos un Cliente que representará al cliente recién conectado. El cliente que desea obtener el historial de mensajes.
Se crea una consulta N1QL para obtener todos los mensajes y ordenarlos según el criterio marca de tiempo valor. Cada resultado de la consulta se transforma en JSON y se añade al canal del cliente para su envío.
¿Cómo utilizar estos dos métodos?
Cuando se establece una conexión websocket, el gestor de clientes registra al cliente para su difusión. Esto ocurre en el directorio iniciar método. En el iniciar hay una sentencia switch para el registro de clientes. Modifiquémosla para que tenga el siguiente aspecto:
|
1 2 3 4 |
case conn := < -manager.register: manager.clients[conn] = true jsonMessage, _ := json.Marshal(&Message{Content: "/A new socket has connected."}) manager.send(jsonMessage, conn) manager.loadMessages(conn) |
Observe que después de registrar la conexión del cliente, tomamos la conexión y la pasamos a la función loadMessages que acabamos de crear. Esto enviará todos los mensajes almacenados previamente a ese cliente en particular.
Guardar los mensajes será un poco diferente.
En el tutorial anterior creamos un leer método. Modifíquelo para que tenga el siguiente aspecto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
func (c *Client) read() { defer func(){ manager.unregister < -c c.socket.Close() }() for{ _, message, err := c.socket.ReadMessage() if err != nil { manager.unregister < -c c.socket.Close() break } msg := &Message { Sender: c.id, Content: string(message), Timestamp:(time.Now()).Unix(), } jsonMessage, _ := json.Marshal(msg) saveMessage(msg) manager.broadcast < -jsonMessage } } |
Lo importante son las siguientes líneas:
|
1 2 3 4 5 6 |
msg := &Message { Sender: c.id, Content: string(message), Timestamp: (time.Now()).Unix(), } saveMessage(msg) |
El servidor recibirá un mensaje del cliente y construirá un verdadero Mensaje con información adicional como quién lo envió y cuándo. A continuación, este mensaje se guarda en la base de datos.
Intenta ejecutar la aplicación Golang de nuevo con el cliente Angular 2. Ahora debería guardar los mensajes.
Conclusión
Acabamos de ver cómo añadir Couchbase a una aplicación ejemplo anterior de websocket que escribí. En el ejemplo anterior teníamos una aplicación de chat cliente y servidor que se comunicaba usando websockets. Expandimos este ejemplo y empezamos a guardar los datos de los mensajes en Couchbase para que pudieran ser cargados por nuevos participantes del chat.
Buen trabajo
Gracias.