Los servidores Comet – APE III – Objetos

Untitled Document

Objetos del Core

Formato Objeto valor
RAW todas las respuestas del servidor, tienen este formato
raw Identificador de la orden (LOGIN, IDENT,…)
time tiempo en formato Unix
data objeto JSON con la informacion a devolver
CMD Todos los comandos que se envian al servidor, ya sea por POST o por GET. Es un objeto JSON con la siguiente estructura
cmd nombre comando
chl numero de serie de la interrogacion; va aumentando continuamente
sessid identificador de sesion
params Es un objeto JSON que contiene parejas de nombre-valor, en funcion de lo que se quiera hacer

Comandos

CONNECT cmd CONNECT Inicio de la conexion
chl 0
params transport Forma de transporte
(APE.Config.transport =0
)
Long Polling Como en el formato tradicional, el cliente inicia una peticion al servidor, pero si este no tiene informacion para transmitir, en lugar de enviar un registro vacio, que abierto el canal hasta que tenga algo que enviar, o se produzca un timeout; en ese momento, enviara el registro de cierre, y el cliente iniciara una nueva peticion
(APE.Config.transport = 2
)
JSONP Con este metodo, se puede trabajar con conexiones a distintos dominios
(APE.Config.transport = 1) XHRStreaming Este metodo, es similar al “Long Polling”, pero cuando se envia informacion, la conexion no se cierra. Solo trabaja con navegadores compatibles basados en Gecko y Webkit (Safari, Crome, Firefox,) Si el navegador no lo soporta, APE_JSF cambia a “Long Polling”
(APE.Config.transport = 6) WebSocket Solo funciona con las ultimas versiones de APE. El servidor ha de correr en el puerto 80 o el el 443
JOIN cmd JOIN Usuario se une a canal
chl ?
sessid sesion identificador de sesion
params
chanenels nobre de canales Nombre de los canales a que se une, separados por comas
SEND cmd SEND
chl ?
sessid Identificador de sesion
params pipe objeto
data objeto JSON con parejas de nombre:valor

RAWs

LOGIN raw LOGIN respuesta a CONNECT
time tiempo unix
data sessid identificador de sesion
IDENT raw IDENT respuesta a CONNECT
time tiempo unix
data user objeto USER
CHANNEL raw CHANNEL respuesta a un JOIN
time tiempo unix
data pipe Objeto
user Objeto
ERRORES raw ERR
code codigo error
value Descripcion error

Estaticas

Ape.quit Sale de APE y borra sesion
Ape.start
pe.start(); //Send CONNECT command to APE.
ape.start('myNickname'); //Send CONNECT command with a nickname to APE.
Inicia una conexion; se envia el comando CONNECT
Ape.join
ape.join(['channel1', 'channel2']); //Join channels "channel1" and "channel2"
Une la sesion a un o o varios canales
Ape.left Abandona un canal, y genera un pipeDelete
user
Ape.getUserByPubid(pubid)
Recupera un objeto user por su identificador
channel
Ape.getChannelByName('foochannel')
Recupera un objeto canal por su nombre
channel
Ape.getChannelByPubid(pubid)
Recupera un objeto canal por su id
channel Ape.mkChan(‘foo’)
var channel = Ape.mkChan('foo');
Crea un nuevo canal
channel Ape.delChan(‘foo’) var channel = Ape.delChan(‘foo’) Borra un canal(por nombre o por objeto canal)
APE.Core
ape.fireEvent('myEvent', ['argument1', 'argument2'], 1000);
Dispara el evento indicado
pipe new Ape.pipe()
var mypipe = new Ape.pipe()
Crea un objeto pipe
pipe Ape.pipe()
var mypipe = Ape.pipe()
Recupera pipe activa
pipe Ape.getPipe(pubid)
//Get a pipe
var myPipe = ape.getPipe('a852c20b3e5c9889c16fe4ac88abe98f');
//Send a message on the pipe
myPipe.send('Hello world');

ape.join('testChannel');
//This sample is just here to show you how to intercept pipe pubid in pipeCreate event
ape.addEvent('multiPipeCreate', function(type, pipe, options) {
      //Get the pipe object
      var myPubid = ape.getPipe(pipe.getPubid());
      //Send a message on the pipe
      myPipe.send('Hello world');
});
Recupera un enlace por pubid
ape.request.send(comando, parametros);
//This example sends a "JOIN" command,
// and "anotherCommand" with 2 arguments without adding sessid
ape.request.send([
      {
        "cmd":"JOIN",
        "params": {
              "channels": "test1"
               }
       },
      {
        "cmd": "anotherCommand",
        "params": {
              "param1": "value",
              "param2": "value"
           },
        "sessid": false
     }
]);
Permite enviar cualquier tipo de comando hacia el servidor. Si se utiliza desde pipe, se le añade el pubid
ape.request.stack.add(comando,parametros)
//Add two request to the stack
  ape.request.stack.add('testCommand', {"param1":"value"});
  ape.request.stack.add('anotherCommand', {"param1":"value"});
//Send the stack to APE server
  ape.request.stack.send();
Permite almacenar comandos y luego lanzarlos juntos
ape.request.stack.send Envia los parametros agrupados
ape.request.cycledStack.add(comando,parametros)
ape.request.cycledStack.add('mouseMotion', {"x":ev.x, "y":ev.y})
nos permite agrupar un conjunto de comandos que deseamos se envien cada cierto tiempo
ape.request.cycledStack.send();
ape.request.cycledStack.send();
fuerza el envio de los comandos agrupados
ape.request.cycledStack.setTime(ms,booleano);
//Set cycle stack time to 100 ms
ape.request.cycledStack.setTime(100);
Cambia el intervalo de tiempo en que se envian los comandos “cycledStack”, por defecto 350ms

Si el booleano se activa a true, se envia inmediatamente, y se activa el contador de tiempoo a cero

Ape.addEvent()
Ape.addEvent('beforeJoin', function(user, channel)
Los parametros dependeran del evento
Ape.registerCmd(nombre,conSesion,funcion)
Ape.registerCmd("helloworld",true, function(params, infos)
crea comandos, el primer argumento es el nombre del comando
Ape.registerHookCmd(nombre,conSesion,funcion)
Ape.registerHookCmd("foocmd", function(params, infos)
Modifica un comando existente
registerHookBadCmd(function(params,info,raw)
Ape.registerHookBadCmd(function(params, info, raw){
  	Ape.log("Bad RAW received ("+raw+").");
  	//We return nothing so client will receive a BAD_CMD error
});
Recoge cualquier comando que no haya sido registrado
socket Ape.sockClient(port, host, {flushlf: true})

Ape.sockServer(port, “0.0.0.0”, {flushlf: true})

var socket = new Ape.sockClient(port, host, {flushlf: true});
var socket = new Ape.sockServer(port, "0.0.0.0", {flushlf: true});
Conectarse a un host (el parametro flushlf permite evitar que el evento onRead se dispare mientras llegan datos, pasando a dispararse, unicamente, cuando se han recibido todos)
Sesion
Ape.clearSession()
ape.onError('004', function() {
      ape.clearSession();
      ape.initialize(ape.options); //Reinitialize APE class
});
Borra la session, borra eventos, detiene todas las ordenes en curso y resetea sessid y pubid
Ape.setSession()
Ape.setSession({'myKey1':'myValue','myKey2':'myValue2'});
guardar variables en sesion
Ape.getSession(‘myKey’, function())
Ape.getSession('myKey', function() {
      console.log(resp.datas.sessions.myKey1);  });
recoge valores de la sesion
client
new APE.Client()
Crear cliente
Ape.log() Envia informacion al log
MySQL
sql Ape.MySQL(“ip:port”, “user”, “password”, “database”)
new Ape.MySQL("ip:port", "user", "password", "database");
Conexion a MySQL. Si se va a conectar a un MySQL local, si quiere utilizar los sockets unix, debe indicar en ip var/run/mysqld/mysqld.sock
string
Ape.MySQL.escape(mylogin)
sql.query("SELECT nick FROM user WHERE login = '"
               +Ape.MySQL.escape(mylogin)+"'");
Permite filtrar los caracteres criticos ( SQL injection )
Utilidades
string Ape.base64.encode(string)
var xxx = Ape.base64.encode('foo')
Codifica MIME base64
string Ape.base64.decode(string)
var xxx = Ape.base64.decode('foo')
Decodifica MIME base64
string Ape.sha1.str(string,key) var result = Ape.sha1.str(“hello world”);

var result = Ape.sha1.str(“hello world”, “mysecretkey”);

var result = Ape.sha1.bin(“hello world”);

Sodificacion SHA1 con o sin clave secreta. La opcion bin genera 20 caracteres binarios
var result = Ape.xorize("key1", "key2");
Realiza una operacion XOR entre los dos valores (la longitud del segunto argumento no puede ser menor que la del primer argumento)
var timeoutID = Ape.setTimeout(func, delayms, [param1, param2, ...]);
Realiza la funcion solicitada cuando transcurre el tiempo indicado
var timeoutID = Ape.setInterval(func, delay[, param1, param2, ...]);
llama a la funcion cada vez que transcurre el tiempo indicado
Ape.clearTimeout(timeoutID)
var timeoutID = Ape.setInterval(function(a, b) {
  	Ape.log("Foo : " + a + " Bar : " + b);
  }, 3000, "foo", "bar");
Ape.clearTimeout(timeoutID);
Detiene la actuacion de un setInterval
include
include('./scripts/foo.js');
ejecuta el contenido del fichero incluido

Objetos

user
level
casttype uni
pubid numero identificador
pipe tuberia a la que se conecta
property
subuser
Ape.registerCmd('foo', true, function(params, info) {
  	info.subuser.sendRaw('bar', {'ok':'true'});
});
Instancia del usuario para la pestaña activa
subUser.sendRaw(nombre,datos,opciones)
Ape.registerCmd('foo', true, function(params, info) {
  	info.subuser.sendRaw('bar', {'ok':'true'});
});
Enviar informacion solo a esta instancia
user subUser.getUser() Obtiene el usuario padre de este
setProperty(datos)
nombre,valor Crea nuevas propiedades o asigna valores
getProperty(nombre) nombre de la propiedad Recupera el valor de una propiedad
join(canal) El usuario se une al canal
left(canal) El usuario deja el canal
pipe accede al objeto pipe
pipe properties
casttype multi
getPubid numero identificacion
addEvent Intercepta los eventos relacionados con el canal
fireEvent activa el evento indicado
fireClobalEvent activa el evento indicado para core y para clientes
Send Envia mensaje por el enlace
sendRaw(nombre,{datos}) envia informacion por la tuberia
setProperty(datos) nombre,valor
getProperty('pubid')
Recupera el valor de una propiedad
myprivate (datos) establece o recupera propiedades privadas
destroy Destruye el enlace
onSend
function(user, params)
onRaw
//Add an event when a new pipe is created
ape.addEvent('pipeCreate', function(type, pipe, options) {
      //Test if the pipe is a "multi pipe" with name test1
      if (type == 'multi' && pipe.name == 'test1') {
          //Add an event when a message is received on the pipe test1
          pipe.onRaw('data', function(data, pipe) {
              console.log('data received on pipe', pipe.name, ' message : ', data.msg);
          });
      }
 //When a new pipe is created, send hello world
      pipe.send('Hello world');
 });
//Join channel test1 and test2
  ape.join(['test1', 'test2']);
---------------------------------------------------
//Server side code

var chan = Ape.getChannelByName('demoChannel');
chan.pipe.sendRaw('testRaw', {'foo': 'bar', 'pipe': chan.pipe.toObject()});

//Client side code (pipe is a pipe object)
pipe.onRaw('testRaw', function(data, pipe) {
      console.log('testRaw received on pipe');
});
onCmd
//Add an event when a new pipe is created
ape.addEvent('pipeCreate', function(type, pipe, options) {
      //Test if the pipe is a "multi pipe" with name test1
      if (type == 'multi' && pipe.name == 'test1') {
          //Add an event when a message is received on the pipe test1
          pipe.onCmd('send', function(data, pipe) {
              console.log('Sending data on pipe pipe', pipe.name, ' message : ', data.msg);
          });
      }
      //When a new pipe is created, send hello world
      pipe.send('Hello world');
  });
//Join channel test1 and test2
ape.join(['test1', 'test2']);
channel
setProperty(datos)
nombre,valor Crea nuevas propiedades o asigna valores
getProperty(nombre) nombre de la propiedad Recupera el valor de una propiedad
userlist
var chan = Ape.getChannelByName('test');
chan.userslist.each(function(user) {
      Ape.log(user.getProperty('pubid'));
});
Recupera la lista de usuarios de ese canal
infos host(string) Http header : “Host :”
client (socket) El objeto socket del cliente
chl (number) contador
ip (string) id del cliente
user (user) objeto user
http (array) Todas las cabeceras HTTP
sendResponse('custom_raw', {'foo':'bar'})
Envia respuesta normalizada
sockClient
var socket = new Ape.sockClient('21', 'example.com', {flushlf: true} );
write(data) Manda informacion al socket
close Cierra la conexion
onConnect
function()
Al establecer conexion
onRead
function(data)
Cuando se reciben datos (ojo a la nota sobre flushlf
onDisconnect function() Cuando se desconecta el cliente
sockServer

var socket = new Ape.sockServer("80", "0.0.0.0", {flushlf: true});
write(data) Manda informacion al socket
close Cierra la conexion
onConnect
function()
Al establecer conexion
onRead
function(data)
Cuando se reciben datos (ojo a la nota sobre flushlf
onDisconnect function() Cuando se desconecta el cliente
onAccept
socket.onAccept = function(client) {
  	Ape.log("New client !");
  	client.write("Hello world\n");
}
Cuando el cliente conecta con el socket
sql
query(sql,funcion(res,error))
sql.query("SELECT * FROM table", function(res, errorNo) {
      if (errorNo)
          Ape.log('Request error : ' + errorNo + ' : '+ this.errorString());
      else {
          Ape.log('Fetching ' + res.length);
          res.each(function(data) {
              Ape.log(data.content);//data.<column name> or data[column_name]
          });
      }
});
interrogacion a la base de datos.

La funcion, es obligatoria.

En la funcion, si se ha hecho un insert, de dispone de la clave insertado por medio de

this.getInsertId()
onConnect
sql.onConnect = function() {
     Ape.log('Connected to mysql server');  }
Al conectar a la base de datos
onError
sql.onError = function(errorNo) {
     Ape.log('Connection Error : ' + errorNo + ' : '+ this.errorString());
Al recibir error de conexion
errorString Recoge elmensaje de error de MySQL
getInsertId Recoge la ultima clave insertada
client
load()

Ordena la carga de scripts en el cliente
addEvent client.addEvent(‘load’, function() {
// Call core start function to connect to APE Server
client.core.start({“name”:”Pooridge”}); });
suscribe al cliente a un evento
properties name nombre del objeto

Eventos

En servidor
adduser function(user) Un usuario se conecta a la aplicacion
deluser function(user) Un usuario se desconecta
beforeJoin,opin,afterJoin function(user,channel) Un usuario se añade al canal
left function(user,channel) Un usuario deja el canal
mkchan function(chanel) Se crea un canal
rmchan function(channel) Se elimina un canal
init Cuando el servidor esta preparado
En cliente
load function() Cuando finaliza la carga de scripts en el cliente
ready function() Cuando el cliente ya esta conectado
onCmd Cuando se va a enviar un comando
onRaw onRaw( string type, function (args,pipe) ) Cuando se reciben datos(Objeto con todos los datos recibidos,el opjeto pipe
userJoin Cuando un usuario se une a un canal
userLeft Cuando un usuario deja un canal
multiPipeCreate
multiPipeDelete
pipeDelete
uniPipeCreate
apeDisconnect Cuando el cliente se desconecta
apeReconnect Cuando el cliente se vuelve a conectar
clearSession Cuando la sesion es borrada
restoreStart Cuando la sesion inicia la restauracion
restoreEnd Cuando la sesion es restaurada
proxyConnect Cuando un usuario se conecta al proxy
proxyRead Cuando el cliente recibe datos dese el proxy
proxyPipeCreate Cuando se crea un nuevo enlace al proxy
proxyClose Cuando el proxy cierra la conexion

Acerca de Miguel Garcia

Programador, Desarrollador web, Formador en distintas areas de informatica y director de equipos multidisciplinares.
Esta entrada fue publicada en Servidores Comet. Guarda el enlace permanente.

Deja un comentario