Tutor de TCP/IP

Introducción

Se trata de un objeto que nos permite implementar un protocolo de comunicaciones TCP/IP en proyectos de Velneo. A través del mismo podremos implementar tanto la parte cliente de un protocolo como la parte servidora, según requieran nuestros proyectos. Es decir, que podremos crear un servicio TCP para comunicarnos con clientes TCP o implementar la parte cliente de un protocolo TCP para comunicarnos como clientes con otros servidores TCP/IP.

Mediante este objeto podremos tanto crear un protocolo propio de comunicaciones como para comunicarnos con desarrollos externos que usen el estándar TCP/IP para comunicarse.

Tanto la programación como la gestión de los protocolos TCP/IP será implementada mediante objetos programables (procesos).

El objeto Protocolo TCP/IP dispone de dos subobjetos programables, llamados intercomunicadores, llamados CLIENT y SERVER.

SERVER es un proceso, y lo programaremos en el caso de que queramos crear un servicio TCP/IP.

CLIENT es una función-proceso (objeto similar al proceso pero que puede recibir parámetros) y que programaremos en caso de crear un cliente TCP/IP.

Existe una carpeta de comandos de instrucción de proceso donde se recogen todos los comandos de instrucción disponibles para los protocolos TCP/IP. Éstos pueden dividirse en dos grupos: comandos para programación de protocolo y comandos de gestión de protocolos.

Comandos para programación de protocolos

Son comandos que usaremos para programar los protocolos, tanto de cliente como de servidor, y son:

Protocolo TCP: enviar buffer: envía un buffer de datos a un cliente/servidor TCP.
Protocolo TCP: enviar fichero: envía un fichero a un cliente/servidor TCP.
Protocolo TCP: enviar línea: envía una línea de datos a un cliente/servidor TCP.
Protocol TCP: enviar byte: envía un byte de datos a un cliente/servidor TCP. Protocolo TCP: enviar entero 16 bits: envía un entero de 16 bits a un cliente/servidor TCP.
Protocolo TCP: enviar entero 32 bits: envía un entero de 32 bits a un cliente/servidor TCP.
Protocolo TCP: recibir fichero: recibe y guarda en disco un fichero enviado por un cliente/servidor TCP.
Protocolo TCP: recibir hasta carácter de marca: permite extraer bytes de una cadena de datos enviado por un cliente TCP hasta un carácter de marca concreto. Protocolo TCP: recibir línea: recibe una línea de datos enviada por un cliente/servidor TCP.
Protocolo TCP: recibir byte: recibe un byte de datos enviado desde un cliente/servidor TCP.
Protocolo TCP: recibir entero 16 bits: recibe un entero de 16 bits enviado desde un cliente/servidor TCP.
Protocolo TCP: recibir entero 32 bits: recibe un entero de 16 bits enviado desde un cliente/servidor TCP.

Estos comandos solamente pueden ser usados en los intercomunicadores de un objeto Protocolo TCP/IP.

Comandos de gestión de protocolos

Son comandos que nos permiten gestionar los protocolos TCP y que podrán ser usados en cualquier objeto proceso o función externo al objeto Protocolo TCP/IP. Son:

Protocolo TCP: ejecutar función cliente: ejecuta la función declarada en el subobjeto (intercomunicador) CLIENT de un objeto Protocolo TCP/IP.
Protocolo TCP: iniciar servicio: inicia un servicio TCP/IP en un puerto determinado. A partir de ese momento cada vez que un cliente TCP/IP establezca una conexión a través de ese puerto, se disparará el proceso programado en el subobjeto (intercomunicador) SERVER del objeto Protocolo TCP/IP.
Protocolo TCP: ¿está iniciado el servicio?: permite comprobar si está iniciado o no el servicio de un objeto Protocolo TCP/IP.
Protocolo TCP: terminar servicio: termina el servicio correspondiente a un objeto Protocolo TCP/IP iniciado en la sesión actual.
Protocolo TCP: terminar todos los servicios: termina todos los servicios correspondientes a objetos Protocolos TCP/IP iniciados en la sesión actual.

En este tutor hemos creado un protocolo para enviar ficheros entre dos aplicaciones de Velneo, por lo tanto, en el objeto protocolo hemos programado la parte cliente y la servidora del protocolo.

Todos los objetos de este tutor los encontraremos en la carpeta tutores/avanzados/protocolo TCP del proyecto de aplicación de vTutor.

En primer lugar explicaremos qué objetos hemos creado en el proyecto de datos, explicaremos el circuito completo programado para la ejecución del protocolo y la explicación del código programado en los intercomunicadores.

Proyecto de datos

En el proyecto de datos hemos creado una variable global, de tipo numérico y con persistencia en memoria, llamada TCP_POR que usaremos para parametrizar el número de puerto que usaremos para establecer la comunicación entre el cliente y el servidor de nuestro protocolo. Se inicializará con el valor 6901.

Proyecto de aplicación

Todo el manejo de los protocolos se hará desde el formulario llamado TUT_TCP. En él se edita una variable local para que podamos especificar la IP en la que estará a la escucha nuestro servicio TCP.

Protocolo de envío de fichero

Crearemos un protocolo en el que el cliente enviará un fichero al servidor, éste lo gudará en su directorio temporal y enviará una confirmación al cliente de que lo ha recibido correctamente. byte (un valor comprendido entre 0 y 255), el servidor lo recibirá y dará de alta un registro en la tabla de mensajes con el dato recibido, fecha y hora de recepción.

Para crear un objeto de este tipo pulsaremos el siguiente icono de la galería de objetos de Velneo vDevelop:. Al objeto le hemos asignado las propiedades siguientes:

Identificador: TUT_TCP.

Nombre: envío recepción de fichero.

Fórmula puerto de escucha: $TCP_POR@velneo_vTutor_dat.dat, que es la variable global que hemos creado a tal efecto en el proyecto de datos de vTutor.

Observaremos cómo este objeto tiene dos subobjetos (intercomunicadores) llamados CLIENT y SERVER.

CLIENT es el subobjeto donde se programará la parte del protocolo relativa al cliente TCP/IP y SERVER es el subobjeto donde se programará la parte del protocolo relativa al servidor TCP/IP.

CLIENT es un subobjeto programable tipo función (similar al proceso, pero que admite parámetros) y SERVER es un objeto programable tipo proceso. Para programar uno de ellos haremos doble clic sobre el mismo para abrir el editor de procesos:

La secuencia de este protocolo será:

Cliente:
Recibirá la senda de un fichero como parámetro.
Calculará su tamaño.
Enviará al servidor una cadena con el nombre del fichero y su tamaño en bytes, separados por un carácter de marca.
A continuación enviará el fichero.
Esperará a que el servidor le devuelve una respuesta.
Emitirá un mensaje con el resultado de la operación.

Servidor:
Recibirá la cadena que contiene el nombre y luego el dato con el tamaño del fichero.
Recibirá el fichero.
Lo guardará en en disco.
Devolverá un 1 si lo ha recibido o un 0 si no ha podido.

Como puede observarse, el protocolo es una "conversación" estructurada y convenida entre el cliente y el servidor.

Programación del intercomunicador CLIENT

Tal y como acabamos de indicar la función CLIENT recibirá un parámetro. Éste será declarado como subobjeto del objeto Protocolo TCP/IP, para ello seleccionamos el protocolo que acabamos de crear y pulsamos el botón del panel de subobjetos y seleccionaremos la opción "variable". A la variable le daremos el Identificador FIC y será de Tipo alfabético.

Una vez creada la variable haremos doble clic sobre el subobjeto CLIENT para editarlo y en sus propiedades le asignaremos como parámetro 1 la variable que acabamos de crear:

Una vez declarado el parámetro ya podremos programar la función cliente:

Rem ( Proceso de cliente )
Libre
Rem ( Obtenemos el tamaño del fichero a enviar )
Get atributos del fichero ( FIC, FCH, HOR, TAM_BYT )
Libre
Rem ( Se envía al servidor una línea con el nombre del archivo, un carácter de marca y su longitud )
Protocolo TCP: enviar línea ( getPathFileName(FIC) + "|" + TAM_BYT, 10 )
Libre
Rem ( Enviamos el fichero al servidor )
Protocolo TCP: enviar fichero ( FIC, 30 )
Libre
Rem ( Esperamos la respuesta del servidor: 1= todo Ok, 2 = no ha podido recibir el fichero )
Protocolo TCP: recibir byte ( BYT, 60 )
Libre
Rem ( Lo que recibimos es un byte así que lo convertimos a carácter con la función getAsciiChar )
If ( getAsciiChar(BYT, "ISO-8859-1")="1" )
    Mensaje ( "Fichero enviado con éxito", Información, ,  )
Else
    Mensaje ( "Ha habido un problema con el envío del fichero", Información, ,  )

Programación del intercomunicador SERVER

Haremos doble clic sobre el subobjeto SERVER y su contenido será:

Rem ( Proceso de servidor )
Libre
Rem ( De la línea enviada por el cliente leemos hasta el carácter de marca, para extraer el nombre del fichero )
Protocolo TCP: recibir hasta carácter marca ( FIC, "|", 10 )
Libre
Rem ( Quitamos el carácter de marca al nombre del fichero )
Set ( FIC, left(FIC, len(FIC)-1) )
Libre
Rem ( Recepción del tamaño del fichero (dato que va a continuación del carácter de marca) )
Protocolo TCP: recibir línea ( TAM, 10 )
Libre
Rem ( Recibir el fichero )
Protocolo TCP: recibir fichero ( tempPath() + "/" + FIC, 10 )
Libre
Rem ( Comprobamos si el fichero ha sido guardado )
¿Existe fichero? ( tempPath() + "/" + FIC, OK_EXI_FIC, TAM_BYT )
If ( (OK_EXI_FIC) & (TAM_BYT = TAM) )
    Libre
    Rem ( Enviamos el byte 1 si todo ha ido bien y un 0 si ha habido algún problema )
    Set ( BYT, stringToNumber(getAsciiCharCode("1", "ISO-8859-1")) )
Else
    Set ( BYT, stringToNumber(getAsciiCharCode("0", "ISO-8859-1")) )
Libre
Protocolo TCP: enviar byte ( BYT, 10 )

Ahora vamos a presentar ambos procesos, para que podamos comprobar mejor la secuencia del protocolo:

Una vez creado el objeto protocolo, crearemos los objetos necesarios para interactuar con él, todos han sido programados en el formulario TUT_TCP que encontraremos dentro de la carpeta de objetos de este tutor.

Hemos creado un control de edición numérica para especificar el nº de puerto del protocolo. Recordemos que para ello habíamos creado la variable global TCP_POR.

Hemos creado un botón SVG para iniciar/detener el servicio TCP. Lo que hará será disparar un manejador de evento para poner a la escucha o detener el servicio TCP en esa sesión de vClient:

Rem ( Iniciar/detener el servicio TCP )
Libre
Rem ( Comprobamos si está iniciado el servicio )
Protocolo TCP: ¿esta iniciado el servicio? ( TUT_TCP@velneo_vTutor_app, OK_TCP_ON,  )
Libre
Rem ( Sin no está iniciado, lo iniciamos. )
If ( !OK_TCP_ON )
    Protocolo TCP: iniciar servicio ( TUT_TCP@velneo_vTutor_app, OK_TCP_ON )
    If ( !OK_TCP_ON )
        Mensaje ( "No se ha podido iniciar el servicio. Asegúrese de que el puerto seleccionado esté disponible.", Información, ,  )
Else
    Libre
    Rem ( Si está iniciado, lo detenemos )
    Protocolo TCP: terminar servicio ( TUT_TCP@velneo_vTutor_app, OK_TCP_DET )
    If ( OK_TCP_DET )
        Set ( OK_TCP_ON, 0 )

Y un botón que dispara un manejador de evento que solicita un fichero y ejecuta el intercomunicador cliente del protocolo, pasando la senda del fichero seleccionado como parámetro:

Rem ( Pedir al cliente que seleccione el fichero a enviar )
Libre
Ventana de selección de fichero ( FIC, OK_FIC_SEL, "*.*", "" )
If ( OK_FIC_SEL )
    Libre
    Rem ( El comando siguiente ejecuta el proceso programado en el intercomunicador cliente del objeto protocolo TCP/IP )
    Protocolo TCP: ejecutar funcion cliente ( TUT_TCP@velneo_vTutor_app, TCP_IP, FICHERO, OK_CON )
    If ( !OK_CON )
        Mensaje ( "Conexión fallida", Información, ,  )

Probando el tutor

Para probarlo necesitamos ejecutar vTutor desde dos sesiones de vClient distintas.

En una de ellas especificaremos el nº de puerto y pondremos en marcha el protocolo y, en la otra, debemos especificar también el nº de puerto, la IP a la que vamos a conectarnos, que será la IP de la máquina donde tengamos ejecutada la otra sesión de vClient, y pulsaremos el botón “enviar fichero”.

results matching ""

    No results matching ""