Documentos de Académico
Documentos de Profesional
Documentos de Cultura
IntroduccionSistemasDistribuidos SE PDF
IntroduccionSistemasDistribuidos SE PDF
CURSO
INTRODUCCIÓN A LOS
SISTEMAS DISTRIBUIDOS
BIENVENIDA
Nos es grato recibirte en esta iniciativa de preparación y actualización de tus
conocimientos en el panorama que presentan las aplicaciones de los sistemas
distribuidos en la industria del Software.
Este curso de introducción a los sistemas distribuidos presenta tanto las bases
teóricas como la aplicación práctica en plataformas actuales de desarrollo, al final
del mismo, contarás con los conocimientos fundamentales requeridos en los
desarrolladores de software modernos.
INTENCIÓN EDUCATIVA
Contribuir al fortalecimiento de tu formación profesional en los temas relevantes de
tecnologías de la información, especialmente en el campo de los sistemas
distribuidos, los cuales se han popularizado por la alta demanda de aplicaciones
de Internet. Con ello tendrás más y mejores oportunidades de incorporarte o
mantenerte actualizado en e l mercado laboral.
OBJETIVOS GENERALES
Al finalizar el curso, el participante será capaz de:
INTRODUCCIÓN
El proyecto PROSOFT surge como una alternativa en la capacitación y formación
de estudiantes y profesionales de la informática, a través de cursos, que
El tema 4, “Lenguajes de programación”, hasta este punto una vez tratados los
temas previos, se estará en posibilidad de desarrollar un pequeño proyecto de
implementación de un sistema distribuido.
Agradecimiento y Reconocimiento
METODOLOGÍA
Se emplearán diferentes técnicas didácticas para cubrir los temas del curso y se
hará referencia en las actividades de aprendizaje sobre el manejo de ellas y la
forma de evaluación basada en rúbricas. Las técnicas didácticas son las
siguientes:
COMPROBACIÓN DE LECTURA
1. Analizar el problema
2. Resolver el problema
3. Elaborar el producto
4. Generar el reporte
FUENTES DE INFORMACIÓN
Referencias bibliografías:
REGLAS Y EVALUACIÓN
El curso tiene una serie de actividades que sirven como medio para que los
alumnos encuentren significado y propicien la construcción de los conocimientos
bajo las estrategias didácticas que el programa señala. No se trata de ejercicios
memorísticos o de una labor informativa del tutor sino de desafíos, ejercicios e
investigaciones desarrolladas por los alumnos con un enfoque de aprendizaje
cooperativo e independiente. Los alumnos deberán entregar con oportunidad las
tareas individuales y en equipo determinadas para cada tema y con el formato
adecuado. El informe de los ejercicios prácticos que deban presentar tiene la
modalidad de que detallen o amplíen el funcionamiento de ellos o en su caso la
compilación correspondiente. Los alumnos deberán participar interactivamente
mediante los apoyos de e-mail, foros, y Chat para retroalimentar su trabajo en
equipo y comunicación con el tutor. Rúbrica de evaluación de comprobación de
lecturas como Evaluación Síntesis.
Tareas que se integran: TI (2.1, 2.2.1, 2.2.2, 2.3), TI (3.2, 3.4, 3.5, 3.6) y TI (5).
CONTENIDO
BIENVENIDA.....................................................................................................................................................................II
INTENCIÓN EDUCATIVA ...........................................................................................................................................II
OBJETIVOS GENERALES ...........................................................................................................................................II
INTRODUCCIÓN .............................................................................................................................................................II
METODOLOGÍA ..............................................................................................................................................................V
FUENTES DE INFORMACIÓN.................................................................................................................................VI
REGLAS Y EVALUACIÓN.......................................................................................................................................VII
1. INTRODUC CIÓN ................................................................................................................................................... 1
1.1. FUNDAMENTOS .................................................................................................................................................3
1.2. VENTAJAS Y FACTORES DE DISTRIBUCIÓN.................................................................................................23
1.3. DESVENTAJAS Y FACTORES A CONSIDERAR...............................................................................................25
1.4. EVOLUCIÓN.....................................................................................................................................................26
2. ARQUITECTURA CLIENTE SERVIDOR ..................................................................................................33
2.1. FUNDAMENTOS DE A RQUITECTURA CLIENTE SERVIDOR .........................................................................33
2.2. COMUNICACIÓN ENTRE PROCESOS ..............................................................................................................40
2.3. M ODELO DE CAPAS........................................................................................................................................80
3. TECNOLOGÍAS DE DESARROLLO............................................................................................................ 91
3.1. INTRODUCCIÓN AL MIDDLEWARE................................................................................................................98
3.2. PROGRAMACIÓN DE TRANSACCIONES......................................................................................................104
3.2 PROGRAMACIÓN DE TRANSACCIONES ...............................................................................................................108
3.3. CORBA ........................................................................................................................................................124
3.4. RMI ...............................................................................................................................................................161
3.5. COM+ ...........................................................................................................................................................166
3.6. W EB SERVICES.............................................................................................................................................221
4. LENGUAJES DE PROGRAMACIÓN.........................................................................................................227
4.1. LENGUAJES Y PLATAFORMAS DE DESARROLLO.....................................................................................227
4.2. DESARROLLO DE UN SISTEMA DISTRIBUIDO ...........................................................................................237
5. COMPUTACIÓN MÓVIL...............................................................................................................................248
5.1. A NTECEDENTES EN COMPUTACIÓN M ÓVIL .............................................................................................248
5.2. PARADIGMAS DE LA COMPUTACIÓN MÓVIL .............................................................................................260
5.3. LENGUAJES Y A MBIENTES DE PROGRAMACIÓN DE COMPUTACIÓN M ÓVIL .......................................263
5.4. A PLICACIONES MÓVILES............................................................................................................................293
Objetivos
Al término del estudio del tema de introducción, el participante comprenderá:
Actividades (1)
Actividad 1.1
Realizar una síntesis sobre los conceptos de introducción del curso, tomando
como base el Material de Apoyo .
Una vez completada la Actividad 1.1, colocar su documento en Tarea Individual (1)
Actividad 1.2
Introducción
La computación distribuida ha ido tomando más y más importancia con el impresionante
desarrollo de las telecomunicaciones y conforme los avances tecnológicos han hecho
posible la construcción de computadoras que caben en un escritorio pero con
procesadores muy poderosos y grandes capacidades de memoria y disco; Millones de
usuarios dependen de sistemas distribuidos diariamente para hacer transacciones
bancarias, reservaciones de vuelos, telefonía, enviar correos electrónicos, obtener
información de todo tipo y realizar operaciones de compra-venta.
1.1. Fundamentos
A pesar del tiempo transcurrido, esta definición sigue siendo, en esencia, válida.
Así, para Coulouris un sistema distribuido es aquél que está compuesto por
varias computadoras autónomas conectadas mediante una red de
comunicaciones y equipadas con programas que les permitan coordinar sus
actividades y compartir recursos. Bal ofrece una definición muy similar: ``Un
sistema de computación distribuida está compuesto por varios procesadores
autónomos que no comparten memoria principal, pero cooperan mediante el
paso de mensajes sobre una red de comunicaciones''. Y según Schroeder, todo
sistema distribuido tiene tres características básicas:
Una característica muy importante es que las diferencias entre las computadoras
y las maneras en que estas se comunican no son transparentes para el usuario
final, esto mismo aplica para la organización interna del sistema distribuido. Otra
característica importante es que los usuarios y las aplicaciones pueden
interactuar con un Sistema Distribuido de manera consistente y uniforme, sin
importar donde y cuando se lleve a cabo la interacción.
Todo Sistema Distribuido bebe también ser relativamente fácil poder expandir, lo
cual se logra al tener computadoras independientes, pero al mismo tiempo
“esconder” las funciones de dichas computadoras en el sistema. Normalmente
un sistema distribuido debe de estar siempre disponible a pesar de que ciertas
partes que lo conforman puedan no estar funcionando. Los usuarios y las
aplicaciones no deben de notar en ningún momento que estas partes están
siendo reemplazadas o reparadas, o que se han agregado nuevas partes al
sistema para poder dar servicio a más usuarios o aplicaciones.
1.1.2.1 Heterogeneidad
Un ejemplo de esto lo podemos ver muy claro en Internet, ya que es una red que
esta conformada por muchos tipos de redes (Figura 1) cuyas diferencias se
encuentran enmascaradas, puesto que todas las computadoras que se conectan
a este utilizan los protocolos de Internet para comunicarse una con otra, así una
computadora conectada a una red Ethernet puede comunicarse con otra
computadora conectada a una red Token Ring, basta con que se haga una
implementación de los protocolos de Internet para cada una de esas redes.
Otro término importante para este apartado es el de código móvil, que se emplea
para referirse al código que pude ser enviado de una computadora a otra para
que esta última la ejecute, un ejemplo de un código móvil son los applets de
java, que son enviados del servidor a la computadora del cliente para que este
los ejecute en su explorador de Internet. Al implementar un código de este tipo
podemos encontrarno s con el problema de que el conjunto de instrucciones (a
nivel máquina) de una computadora puede no ser el apropiado para otra
máquina, por ejemplo, un usuario de una PC puede enviar un archivo ejecutable
a un usuario de Linux y este último no será capaz de ejecutar dicho archivo.
Para solucionar este problema se han creado lo que se conocen como máquinas
virtuales, las cuales proveen un modo de crear código ejecutable sobre cualquier
hardware, ya que el compilador de un lenguaje concreto generará un código
para una máquina virtual y esta se encargará de “traducir” dicho código al
apropiado para un hardware particular, así, un compilador de Java producirá un
código para la máquina virtual de Java, y esta última sólo necesitará ser
implementada una sola vez para cada máquina en la que se va a ejecutar.
parámetros de entrada, los valores de salida y los posibles errores que pueden
obtenerse al invocarse dichas funciones.
1.1.2.3 Seguridad
El alto valor de que tiene la información es la razón principal por la que esta se
puede ver amenazada de muchas formas, entre las principales podemos
encontrar:
Si bien no podemos asegurar que un sistema distribuido sea cien por ciento
seguro, es importante contar con un esquema de seguridad lo más robusto
posible, que a pesar de no ser inmune a todo tipo de ataques, si será capaz de
frenar la gran mayoría de dichos ataques. Algunas recomendaciones muy útiles
para los desarrolladores, administradores e implementadotes de un sistema
distribuido se presentan a continuación:
La información fluye a través de los distintos componentes y/o capas del sistema
y son muchas las instancias en las que se puede mejorar su seguridad. La
recomendación estipula que utilicemos todas estas instancias a pesar de que en
principio puedan parecer redundantes. Por lo general los administradores
tienden a preocuparse por un único punto de acceso desde donde
supuestamente hay una gran probabilidad de ser atacados (por ejemplo, la
conexión a Internet.) Por tanto se invierte esfuerzo y dinero en controlar este
único punto bajo la asunción de que es la única puerta de entrada a los
maleantes y que por tanto, tras asegurarla, todo el sistema quedará seguro. Esto
tiene dos problemas:
incorporan la encriptación como una opción normal para los datos almacenados,
generalmente bajo esquemas propietarios.
1.1.2.4 Escalabilidad
Con respecto a su tamaño: lo que significa que se pueden agregar más usuarios
y más recursos al sistema de una manera muy fácil.
Con respecto a su localización o área de implementación: lo que significa que
tanto los usuarios como los recursos pueden estar en locaciones remotas y
separadas el uno del otro.
Problemas de la Escalabilidad
Cuando se necesita escalar un sistema a un nivel más alto es muy común que
surja algún tipo de problema. Si consideramos la escalabilidad con respecto al
tamaño de un sistema, nos encontramos con las limitaciones que presentan los
servicios, los datos y los algoritmos centralizados.
Técnicas de Escalabilidad
los usuarios, sin necesidad de tener un sólo servidor que proporcione este
servicio.
Recuperación Frente a Fallos: Una vez que fue detectado un fallo y que se ha
decidido arreglarlo, hay que encontrar la mejor manera de hacerlo, y además, de
recuperar el estado del sistema antes de que ocurriera el fallo; esto requiere del
software adecuado para poder reconstruir o bien retractar los cambios que no
fueron completados al momento en que fue interrumpido el sistema, un ejemplo
de esto lo podemos ver en los sistemas manejadores de bases de datos, que se
sirven de una bitácora de las transacciones que se realizan y de acuerdo a esta
bitácora se decide reconstruir o retractar las transacciones hechas sobre la base
de datos antes de que se interrumpiera el funcionamiento de la misma.
Las técnicas antes mencionadas no son las únicas, pero si las más utilizadas,
estas técnicas deben de proporcionar las herramientas necesarias para
aumentar el grado de disponibilidad de cualquier sistema distribuido, ya que al
saber como tratar un fallo del sistema, también es posible encontrar la manera
de reconfigurar el sistema para que los servicios que este proporciona no sean
interrumpidos, o que en el peor de los casos sólo sean afectados los servicios
proporcionados por los componentes afectados.
1.1.2.6 Concurrencia
1.1.2.7 Transparencia
Con todo esto en mente es posible diseñar un sistema que cuente con las
características necesarias para lograr la transparencia en tantos aspectos como
sea posible. Los dos más importantes son la transparencia de acceso y la
transparencia de ubicación, la primera se relaciona con la forma en que
representamos los datos en un sistema distribuido, es importante presentar al
usuario o a los programadores el acceso indistinto a recursos locales o remotos,
sin que este se de cuenta de la ubicación de los mismos, lo que al mismo tiempo
nos conduce a tener transparencia de ubicación dentro del sistema.
Por otro lado, la replicación juega un papel muy importante dentro de un sistema
distribuido, en el caso de los nombre de domino, los servidores DNS trabajan en
un sistema de replicación distribuida organizado jerárquicamente que hace
posible el acceso simultáneo a millones de usuarios que requieren de la
información que contiene esta base de datos, sin embargo, la transparencia de
la replicación en el sistema consiste en esconder que existen varias copias de
un mismo recurso, y por lo general implica que dentro del mismo sistema se
cuenta con transparencia de ubicación, puesto que de otra manera sería
imposible acceder a las copias de los recursos con que se cuenta.
La gran mayoría de los usuarios de los servicios computacionales son cada vez
más cultos y competentes por lo que dichos usua rios desean operar sus propios
sistemas, a su manera, por lo que no están contentos con los sistemas
centralizados que llevan el control sobre los sistemas que son desarrollados,
cuándo, cómo y por quiénes son operados. La computación distribuida ofrece a
los usuarios estar más cerca de los procesos y de los datos.
Cuando se trabaja con un sistema distribuido que cuenta con diferentes módulos
de software que pueden integrase como parte de un solo sistema, los usuarios
finales interesados en desarrollar sus propias aplicaciones pueden hacerlo
utilizando sus propias máquinas, lo que trae como consecuencia la reducción del
costo y tiempo de desarrollo de una nueva aplicación.
1.2.9 Crecimiento
Por otro lado, los sistemas distribuidos también exhiben algunas ventajas sobre
sistemas aislados. Estas ventajas son:
1.3.5 Opciones
1.4. Evolución
Para entender el proceso que llevó al nacimiento del concepto que hoy se
conoce como orientación a objetos habría que volver unas cuantas décadas
atrás, hasta la época en la que reinaban FORTRAN y BASIC.
Esto tiene una importancia tremenda. Imaginemos que por error hubiéramos
implementado el atributo diámetro como público. Cualquier otro objeto podría
modificar destrozando la abstracción del mundo real que tratamos de
representar. Diseñar un sistema orientado a objetos también tiene sus riesgos.
Las Clases:
Cuando escribimos un programa, definimos clases, una por cada tipo de objeto,
para que puedan utilizarse en la creación o en la instanciación de nuevos
objetos en memoria durante la ejecución de la aplicación. "Instanciar" objetos a
partir de una clase hace que esos objetos se denominen instancias de la clase.
Usamos el mismo "molde" para crear todas las instancias de un mismo tipo en
nuestro sistema, y podemos pensar en las clases como tipos en nuestro
sistema, y podemos pensar en las clases como tipos de datos, al igual que int o
char, pero con una responsabilidad específica en el sistema.
Así, una clase Válvula define el comportamiento de todas las instancias (de
todas las válvulas) que tengamos en nuestro sistema. A pesar de representar
entidades distintas (cada una con su propio estado), todas se comportarán
exactamente igual o del mismo modo. Si durante nuestro proceso de diseño
descubrimos nuevos tipos de objetos, directamente modificaremos el punto del
programa en donde se define la clase que los genera.
Por ejemplo (retomando el ejemplo del sistema para la industria del petróleo, la
válvula), supongamos que una vez que tenemos nuestro sistema funcionando,
los ingenieros deciden incorporar otro tipo de válvula, una que proporcione un
mayor grado de apertura (o en todo caso que es más sofisticada que las
demás), junto con un nuevo método para abrir la válvula en la posición deseada
y otros métodos privados que permiten conectarla a sensores de posición para
saber cuál es su estado.
Polimorfismo:
Uno de los problemas que pueden surgir en este caso es que la redefinición del
método en las subclases sea totalmente inconsistente con las intenciones
originales de ese método en la superclase.
Una buena jerarquía de clases será la base la reutilización del código en el que
hayamos invertido tiempo y esfuerzo para desarrollar y probar. Con el
encapsulamiento podremos modificar las implementaciones de los métodos sin
alterar el código existente que depende de la interfaz de nuestras clases.
Integrando en un todo las dos anteriores, el polimorfismo nos permitirá crear el
código para que se pueda mantener, sencillo de interpretar y flexible.
Si vamos a ser estrictos, las clases no son una parte esencial de la OOP (sigla
en inglés). Pero dada la influencia de C++ y Java, la mayoría de las personas
piensa que usar clases es la única manera de escribir un programa con
orientación a objetos. En realidad existen dos formas de abordar a la orientación
a objetos en un lenguaje: mediante clases (como en todos los lenguajes
comerciales, tales como C++, C#, Java y otros) y a través de prototipos (como
en Self, Kevo, Omega, todos lenguajes de uso académico).
En los primeros, las clases se utilizan como "fábricas" de objetos. En los últimos
no se necesita la noción de clase; los objetos pueden crearse de la nada en
forma visual o por herencia (a partir de otro objeto), y el código resultante es
mucho más claro.
Tarea Individual
Entregar la síntesis del tema de introducción en documento Word, con el nombre
INTRODUCCION.DOC
Tarea en Equipo
Entregar la síntesis en equipo sobre las características de sistemas distribuidos,
como CARACTERISTICAS.DOC.
Actividad 2.1
Nota Importante:
2. En términos de arquitectura:
Debemos señalar que para seleccionar el modelo de una arquitectura, hay que
partir del contexto tecnológico y organizativo del momento y, que la arquitectura
Cliente/Servidor requiere una determinada especialización de cada uno de los
diferente s componentes que la integran.
• Presentación/Captación de Información
• Procesos
• Almacenamiento de la Información
• Puestos de Trabajo
• Comunicaciones
• Servidores
o Mainframes
o Minicomputadoras
o Especializados (dispositivos de red, imagen, etc.)
• Infraestructura de redes
• Infraestructura de comunicaciones
d) Una ventaja adicional del uso del esquema Cliente/Servidor es que es más
rápido el mantenimiento y el desarrollo de aplicaciones, pues se pueden emplear
las herramientas existentes (por ejemplo los servidores de SQL o las
herramientas de más bajo nivel como los sockets o el RPC).
b) Servicios de Comunicaciones:
Aseguran que cada componente físico de la red sea capaz de comunicarse
exitosamente con otros componentes, tales como LAN a LAN y LAN a WAN. El
sistema puede incluir dispositivos de comunicaciones que manejen diferentes
tipos de protocolos para conectar sistemas heterogéneos.
c) Servicio de Administración:
Administración de Sistemas involucra administración de cambios, de problemas,
operaciones, configuración y rendimiento.
d) Servicios de Aplicación:
Si el recurso compartido es una parte de una aplicación (una función de la
aplicación), estamos hablando de servicios de aplicación. Cada uno de los
procesadores participantes en un ambiente Cliente/Servidor puede mantener
parte del código de la aplicación, el cual debe ser compartido por todos ellos
(interoperabilidad). Esto significa que las partes de una aplicación pueden ser
distribuidas en varios procesadores, locales o remotos.
Objetivos 2.2
Procedure Call). Se crea lo que parece ser una llamada de función y se pone en
marcha un sistema de fondo que hace que tenga lugar en el servidor. El sistema
controla el intercambio de mensajes entre cliente y servidor.
Actividades 2.2
En el primer caso ambos programas deben conectarse entre ellos con un socket
y hasta que no esté establecida correctamente la conexión, ninguno de los dos
puede transmitir datos. Esta es la parte TCP del protocolo TCP/IP, y garantiza
que todos los datos van a llegar de un programa al otro correctamente. Se utiliza
cuando la información a transmitir es importante, no se puede perder ningún
dato y no importa que los programas se queden "bloqueados" esperando o
transmitiendo datos. Si uno de los programas está atareado en otra cosa y no
atiende la comunicación, el otro quedará bloqueado hasta que el primero lea o
escriba los datos.
llamado protocolo UDP, y garantiza que los datos que lleguen son correctos,
pero no garantiza que lleguen todos. Se utiliza cuando es muy importante que el
programa no se quede bloqueado y no importa que se pierdan datos.
ESCENARIO
En este ejercicio veremos las clases de Java que nos permite trabajan de forma
sencilla con sockets TCP.
La interfaz Java que da soporte a sockets TCP está constituida por las clases
ServerSocket y Socket.
2. Socket: es utilizada tanto por el cliente como por el servidor. El cliente crea
un socket especificando el nombre DNS del host y el puerto del servidor, así se
crea el socket local y además se conecta con el servicio. Esta clase proporciona
los métodos getInputStream y getOutputStream para acceder a los dos streams
asociados a un socket (son bidireccionales), y devuelve tipos de datos
InputStream y OutputStream, respectivamente, a partir de los cuales podemos
construir BufferedReader y PrintWriter, respectivamente, para poder procesar los
datos de forma más sencilla.
5. Cerrar el socket.
La forma de implementar un servidor será:
Vamos a ver todo esto con un sencillo ejemplo: una aplicación cliente/servidor
de eco, es decir, el servidor repite lo mismo que le envía el cliente, hasta que el
cliente quiere finalizar el servicio, para lo cual envía la palabra "Bye" al servidor.
import java.net.*;
import java.io.*;
try {
socketCliente = new Socket("localhost", 4444);
BufferedReader stdIn =
new BufferedReader(new InputStreamReader(System.in));
String linea;
try {
while (true) {
// Leo la entrada del usuario
linea = stdIn.readLine();
// La envia al servidor
salida.println(linea);
// Envía a la salida estándar la respuesta del servidor
linea = entrada.readLine();
System.out.println("Respuesta servidor: " + linea);
// Si es "Bye" es que finaliza la comunicación
if (linea.equals("Bye")) break;
}
} catch (IOException e) {
import java.io.*;
import java.net.*;
} catch (IOException e) {
System.out.println("IOException: " + e.getMessage());
}
salida.close();
entrada.close();
socketCliente.close();
socketServidor.close();
}
Ejercicio RPC
Los RPC permiten llamar a una función que está en otro programa y
generalmente en otra máquina, para lo cual el paso de parámetros a la función
remota se efectúa a través de algún protocolo de representación de datos (XDR,
eXternal Data Representation).
Dentro de las funciones para programar con RPC existen tres niveles:
ESCENARIO
PROGRAMA SERVIDOR
Listado 1:
/*
Ejemplo del uso de los RPC de Sun
Este programa permite obtener la hora de una máquina
rpc_server _hora
*/
#include <rpc/rpc.h>
#include <time.h>
#include "def_rpc.h"
void *servidor_hora();
void *servidor_hora() {
/* servidor de hora */
struct tiempo str_tiempo, *ap_str_tiempo = &str_tiempo;
time_t t;
printf ("RECIBI RPC\n");
t = time(NULL);
ap_str_tiempo->segundos = t;
ap_str_tiempo->s_tiempo = localtime(&t);
ap_str_tiempo->cad_hora = ctime(&t);
return (void *) ap_str_tiempo;
}
PROGRAMA CLIENTE
El programa cliente (listado 2) toma los ar-gumentos con los que fue mandado a
ejecutar y entra en un ciclo llamando a la función "callRPC”, que se encarga de
ejecutar el llama-do a un RPC.
Listado 2
/*
Ejemplo del uso de los RPC de Sun
Este programa permite obtener la hora de una máquina
rpc_cliente_hora
*/
#include <stdio.h>
#include <rpc/rpc.h>
#include "def_rpc.h"
#define T_ESPERA 10 /* tiempo de espera en segundos */
main(narg,arg){
char **arg;/* programa cliente de hora con rpcs */
struct tiempo hora;
int espera = T_ESPERA;
enum clnt_stat stat;
if( narg < 2 ){
fprintf(stderr,"uso: %s máquina tiempo_de_espera\n",arg[0]);
exit(1);
}
if( narg == 3 )
espera = atoi(arg[2]);
printf ("VOY A MANDAR\n");
clnt_perrno(stat) ;
exit(2);
}
Listado 3
/*
Definiciones para rpcs del ejemplo de hora
Sirven tanto para el cliente como el servidor
*/
#define HORA_PROG 555555555 /* Número del programa */
#define HORA_VERS /* versión */
#define PIDEHORA_NUM /* procedimiento 1 pide hora */
bool_t xdr_hora();
bool_t xdr_cadena_32();
bool_t xdr_stiempo();
struct tiempo {
time_t segundos;
struct tm *s_tiempo;
char *cad_hora;
}
XDRs
Listado 4
/*
Ejemplo del programa de hora con rpcs
xdrs
*/
#include <rpc/rpc.h>
#include <time.h>
#include "def_rpc.h"
XDR *xdrsp;
struct tiempo *ap_hora;
xdr_int(xdrsp,&ap_tiempo->tm_hour) &&
xdr_int(xdrsp,&ap_tiempo->tm_mday) &&
xdr_int(xdrsp,&ap_tiempo->tm_mon) &&
xdr_int(xdrsp,&ap_tiempo->tm_year) &&
xdr_int(xdrsp,&ap_tiempo->tm_wday) &&
xdr_int(xdrsp,&ap_tiempo->tm_yday) &&
xdr_int(xdrsp,&ap_tiempo->tm_isdst))
return (TRUE);
else
return (FALSE);
}
• Paso de mensajes
• Llamado a procedimientos remotos
• Transacciones
El orden en la lista anterior indica que cada forma de comunicación puede ser
construida en base a la anterior. En otras palabras, a mayor número, mayor nivel
de abstracción.
Paso de mensajes
Existen varios métodos por los que un cliente puede conocer o determinar la
dirección del servidor, a continuación se mencionan tres de ellas:
2. Primitivas de Comunicación
Primitivas con bloqueo o sin bloqueo.- una primitiva tiene una semántica sin
bloqueo cuando su ejecución no produce un retardo en el proceso que la invoca;
de otra manera la primitiva es con bloqueo.
Los sistemas con buffer son más difíciles de controlar debido a la necesidad de
crear, destruir y mantener los buffers.
Transacciones
Dentro de los sistemas distribuidos, hay muchos casos en que una sola
comunicación no resuelve problemas específicos de interacción entre dos
procesos (por ejemplo, un retiro de una cuenta bancaria). La interacción entre
los procesos puede ser una secuencia de comunicaciones y cálculos. En estas
situaciones, es adecuado operar en base a transacciones.
3. Propiedades
Las transacciones tienen las siguientes propiedades:
La segunda fase inicia cuando todas las respuestas de los esclavos han llegado.
En este momento, el maestro verifica si todos los esclavos pueden llevar a cabo
su trabajo. Si la respuesta es afirmativa, el maestro les informa que ejecuten el
trabajo. En caso contrario, es decir, si uno o más esclavos rechazan la petición
inicial, el maestro aborta la operación y pide a los esclavos que desbloqueen su
objeto y restablezcan su estado inicial.
El modelo OSI tiene siete capas. Los principios aplicados para el establecimiento
de siete capas fueron:
Capa Física
Comprende:
Ejemplos:
RS-232C, RS -449
Comprende:
Ejemplos:
SDLC, HDLC, LAPB, LLC (IEEE 802.2).
Comprende:
Ejemplos:
CLNP de OSI
IP de la familia TCP/IP
IPX de Novell
X.25 PLP (Packet-Level Protocol)
Capa de Transporte
Comprende:
Ejemplos:
TP0-TP4 de OSI
TCP y UDP de la familia TCP/IP
SPX de Novell
Capa de Sesión
Comprende:
Ejemplos:
RPC de Sun Microsystems
Protocolo OSI Session
Comprende:
Ejemplos:
ASN.1 (Abstract Syntax Notation) de OSI
XDR (External Data Representation) de Sun Microsystems
DES (Data Encryption Standard)
Capa de Aplicación
Comprende:
• Aplicaciones de red.
• Interfaces de programación para aplicaciones de us uario (APIs).
La primera red que adoptó TCP/IP, hacia 1980, fue la ya existente ARPANET.
Esta red se convirtió en la base de la Internet que en nuestros días conecta a
más de 30,000 subredes y 2.5 millones de computadoras en unos 107 países.
Application Application
messages or streams
Transport Transport
Datagrams (UDP) or
segments (TCP)
Internet Internet
IP datagrams
network frames
Network Hardware
Cada nodo tiene una dirección física (llamada dirección MAC en el contexto de
redes locales) asociada con el dispositivo de hardware que lo conecta con la red.
Por ejemplo, en Ethernet, una dirección física es un número de 6 bytes; las
redes X.25 usan el estándar X.121 que define direcciones físicas como números
de 14 dígitos.
Dado que las direcciones IP son independientes del tipo de red, éstas pueden
ser usadas para enviar paquetes entre distintos tipos de redes. En cada tipo de
red, el software de TCP/IP hace la correspondencia entre direcciones físicas y
direcciones IP.
Clases de Direcciones IP
Una dirección clase A consta de 1 byte para la porción de red y 3 bytes para el
host. El bit más significativo de la porción de red es siempre 0. Esto permite 126
redes clase A (1 a 126) con más de 16 millones de nodos en cada una.
Una dirección clase B consta de 2 bytes para la porción de red y 2 bytes para el
host. Los bits más significativos de la porción de red son siempre 10. Así, es
posible tener 16 mil (214) redes clase B con más de 65,000 nodos cada una.
Una dirección clase C consta de 3 bytes para la porción de red y 1 byte para la
porción de host. Los tres bits más significativos de la porción de red son siempre
110. Esto permite aproximadamente dos millones de redes clase C con un
máximo de 254 nodos cada una.
Direcciones Reservadas
Protocolos
El Protocolo IP
Protocolos de Transporte
El Protocolo UDP
El Protocolo TCP
2.2.4 Sockets
Introducción
¿Qué es un socket?
Definición Informal
Definición Formal
Una conexión de red entre dos procesos queda completamente definida por una
asociación, la cual es una quinteta formada de la siguiente manera:
Una vez que un socket está conectado (es decir, abierto) se pueden realizar
operaciones de lectura y escritura sobre él.
Socket
Una aplicación llama a socket para crear un nuevo socket. La llamada regresa
un descriptor (el cual es del tipo entero) del socket creado.
Uso:
s = socket (family, type, protocol);
Argumentos:
Connect
Uso:
retcode = connect (socket, addr, addrlen);
Argumentos:
Write
Tanto clientes como servidores usan write para enviar información a través de
una conexión de red. Esta función se usa principalmente sobre TCP.
Uso:
retcode = write (socket, buf, buflen);
Argumentos:
Read
La llamada read es usada tanto por clientes como por servidores para recibir
datos de una conexión de red, principalmente sobre TCP.
Uso:
retcode = read (socket, buf, buflen);
Argumentos:
Uso:
retcode = close (socket);
Argumentos:
Bind
Cuando se crea un socket, éste no sabe cuáles son las direcciones local y
remota de la conexión. Una aplicación llama a bind para especificar la dirección
local del socket. Esta llamada es usada principalmente por servidores para
indicar el puerto conocido en el cual esperarán conexiones.
Uso:
retcode = bind (socket, localaddr, addrlen);
Argumentos:
Listen
Cuando se crea un socket, éste no queda ni activo (listo para ser usado por un
cliente) ni pasivo (listo para ser usado por un servidor). Los servidores
orientados a la conexión llaman a listen para poner un socket en modo pasivo,
es decir, listo para aceptar peticiones de conexión. Esta llamada no aplica para
UDP.
Uso:
retcode = listen (socket, queuelen);
Argumentos:
Accept
Después de que un servidor llama a socket para crear un socket, bind para
especificar la dirección local, y listen para poner el socket en modo pasivo, se
llama a la función accept con el fin de crear un nuevo socket que atienda a la
nueva conexión. El socket original, que maneja un puerto conocido, se usa
para aceptar otras peticiones de conexión.
Uso:
newsock = accept (socket, addr, addrlen);
Argumentos:
El acoplador del cliente envía los mensajes de red al sistema remoto. Esto
requiere una llamada de sistema en el kernel local.
Consideraciones de Transparencia
Aunque el objetivo del mecanismo de RPC es hacer que un procedimiento
remoto se pueda invocar en forma transparente, es necesario considerar los
siguientes puntos:
Paso de parámetros.
Asociación entre el cliente y el servidor.
Protocolo de transporte.
Manejo de excepciones.
Semántica de la llamada.
Representación de datos.
Rendimiento.
1. Paso de Parámetros
3. Protocolo de transporte
4. Manejo de excepciones
Dentro de una llamada a una función remota hay muchas cosas que pueden
fallar. Podemos experimentar problemas con la red, con nuestra máquina o
incluso con la máquina que corre el procedimiento remoto. Muchas veces el
cliente desea detener el procedimiento que llamo por problemas en los datos,
por falta de tiempo o incluso por indecisiones. También puede suceder que el
cliente salga de su sesión de Internet cuando todavía no se termina de ejecutar
el procedimiento remoto, lo que generaría un fallo cuando el servidor intente
mandar el resultado o la conclusión del procedimiento al usuario.
5. Semántica de la llamada
Exactamente una vez significa que el procedimiento remoto fue ejecutado una
vez, nada más. Este tipo de operación es difícil de lograr debido a la posibilidad
de caídas de los servidores.
Como máximo una vez significa que el procedimiento remoto no fue ejecutado o
que fue ejecutado cuando más una vez. Si el cliente obtiene un regreso normal,
sabemos que el procedimiento remoto fue ejecutado una vez. Pero si se obtiene
una condición de error, no se sabe si el procedimiento remoto fue ejecutado una
vez o ninguna.
Al menos una vez significa que el procedimiento remoto fue ejecutado en una
ocasión pero posiblemente más veces. Esto es típico para procedimientos
idempotentes: el cliente se mantiene transmitiendo su petición hasta que recibe
una respuesta válida. Pero si el cliente tiene que enviar su petición más de una
vez para recibir una respuesta válida, hay una posibilidad de que el
procedimiento remoto fue ejecutado más de una vez.
6. Representación de datos
7. Rendimiento
Actividad 2.3
Para estudiar el Modelo de Capas o de Aplicación para diseñar programas
estudiaremos algunos fundamentos teóricos y posteriormente se plantearán
escenarios de una aplicación modelada
Instrucciones
Material 2.3.
Ejemplo a 2 Capas
Cliente Cliente
Presentación Presentación
(Servicios de Usuario) Presentación (Servicios de Usuario) Presentación
Servidor Servidor
Ejemplo a 3 Capas
Presentación
(Servicios de Usuario) Presentación Cliente
Red
Middleware
Reglas de Negocio Reglas de Negocio +
(Lógica de Aplicación) (Lógica de Aplicación)
Servidor1
Red
Datos y Recursos
(Servicios de Datos) Datos Servidor2
Base de Datos
Por ejemplo, para una aplicación diseñada a 3 capas podemos tener una
aplicación cuya capa de presentación pueda ser provista de dos formas. Una de
ellas a través de la interfaz gráfica que puede ser construida con un lenguaje de
programación. La otra a través de un navegador para Internet (browser)
empleando páginas Web (construidas en forma estática o dinámica).
Escenario 2.3.
La aplicación del ejemplo consiste en una interfaz gráfica que solicita al usuario
su nombre y fecha de nacimiento. A través de dos botones principales, el
primero “Calcular edad” y el segundo “Guardar”. “Calcular edad” obtendrá la
fecha de sistema y calculará la diferencia en años entre ésta y la fecha de
nacimiento capturada. “Guardar” almacenará la información en una base de
datos.
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9) (8.5-7) (6.5-0)
La información La información La información
revisada permitió revisada permitió revisada no
Aplicación de a los estudiantes a los estudiantes permitió a los
la comprender con comprender estudiantes
Información claridad los solamente los comprender
ejercicios y ejercicios y los ejercicios y
programas. programas. programas.
(10-9) (8.5-7) (6.5-0)
Los estudiantes
han demostrado el
Los
significado del
Los estudiantes estudiantes no
material
han demostrado han hecho
elaborando
el significado del contacto con el
Conexiones correctamente, material,
material
mientras
Especialistas incorporándolo simplemente
extienden y
correctamente sin incorporar
explican la
en el estudio del la información
información,
tema. en su estudio
incorporándola en del tema.
el estudio del
tema.
Total de Puntos Obtenidos
3. Tecnologías de Desarrollo
Panorama General
Definición de Actividades
Agenda
Metodología Actividades
Evaluación
Metodología
• Introducción
• Estrategias de Aprendizaje
Introducción
Estudio de Casos
Con la técnica de EC los alumnos aprenderán a:
1) Analizar y ejercitar sobre un caso típico de estudio.
2) Colaborar y dirigir el aprendizaje utilizando recursos adecuados.
3) Defender el conocimiento adquirido y actuar en forma responsable.
Actividades
Subtema Actividad de Aprendizaje
Actividades
Con base al estudio del tema 3 de tecnologías de
desarrollo, los alumnos propondrán por equipo, de forma
preliminar, el tópico de implementación de un sistema
distribuido trivial, con objeto de cubrir más adelante el
tema 4, Lenguajes de Programación.
Evaluación
Rúbrica de
evaluación para
el proceso de
ABP
Evaluación
Rúbrica de
evaluación para
el proceso de
EC
Evaluación
Rúbrica de evaluación para el proceso de AOP
Evaluación
Rúbrica de evaluación de Ejercicios Prácticos
Escenario Middleware
Introducción al Middleware
Escenario
Escenario Middleware
• Un sistema distribuido organizado como un middleware:
o Sistema abierto independiente del fabricante.
o Sin dependencia del hardware y sistema operativo subyacente.
§ DCE, CORBA, DCOM, …
Red de Interconexión
Escenario Middleware
• El paradigma significa "un diseño, ejemplo o modelo." En el estudio de
cualquier tema de gran complejidad, es útil para identificar los diseños
básicos o modelos y clasificar el detalle según estos modelos.
Actividad 3.1
Introducción al Middleware
Formas de Middleware
Consideraciones útiles
Aplicación que habilita servicios a los que dan acceso de las aplicaciones de
servicios distribuidos y la red subyacente. Este tipo de servicios incluye los
monitores de transacciones y los servicios de base de datos como el lenguaje de
consulta estructurada (SQL).
Puntos de
Arriba del En el Debajo del
Atributos Atributo
Estándar Estándar Estándar
Obtenidos
(5 -4.5) (4 -3.5) (3-0)
Sus
Participación,
Sus intervenciones
pero sus
intervenciones mostraron
intervenciones
mostraron relación con
no estaban
bastante el escenario,
Definición del relacionadas
relación con pero no
Problema con el
el escenario y lograron
escenario ni
fueron la base aterrizarlas
condujeron
para abordar del todo para
para abordar
el problema. abordar el
el problema.
problema.
(10-9 ) (8.5 -7) (6.5 -0)
La La
información información La
reunida reunida información
incluye los incluye los reunida está
Profundidad de elementos elementos incompleta y
Estudio esenciales del esenciales del no incluye los
tema y un tema y un elementos
estudio en estudio esenciales del
profundidad normal del tema.
del tema. tema.
(5 -4.5) (4 -3.5) (3-0)
Su aportación Hizo
fue bastantes Hizo pocas
determinante aportaciones, aportaciones
para la pero le falto y sin relación
Solución/explicación
elaboración aterrizarlas en con las
del problema
del reporte propuestas posibles
final de la concretas de soluciones del
solución del solución al problema.
problema. problema.
Escenario Transacciones
Programación de Transacciones
Escenario
Escenario de Transacciones
Escenario de Transacciones
EJERCICIO
Analice el resultado
Ahora sólo ejecute sólo las primeras 2 líneas del código anterior que consta de 4 líneas.
Cierre la aplicación con la que introduce los comandos SQL
Vuelva a entrar a la aplicación y consulte el contenido de la cuenta.
Analice la importancia del manejo de transacciones.
Actividad 3.2
Programación de Transacciones
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9 ) (8.5-7) (6.5-0)
La información
La información La info rmación
revisada
revisada permitió revisada no
permitió a los
Aplicación de a los estudiantes permitió a los
estudiantes
la comprender con estudiantes
comprender
Información claridad los comprender
solamente los
ejercicios y los ejercicios y
ejercicios y
programas. programas.
programas.
(10-9 ) (8.5-7) (6.5-0)
Los estudiantes
han demostrado
Los
el significado del
Los estudiantes estudiantes no
material
han demostrado han hecho
elaborando
el significado del contacto con
correctamente,
Conexiones material el material,
mientras
Especialistas incorporándolo simplemente
extienden y
correctamente sin incorporar
exp lican la
en el estudio del la información
información, en su estudio
tema.
incorporándola en
del tema.
el estudio del
tema.
Total de Puntos Obtenidos
Por las siglas de estas características en inglés resulta la palabra ACID, que
significa ácido. Por lo que suele llamarse “pruebas o características ácidas” el
que un administrador de transacciones cumpla con ellas.
EJERCICIO
BEGIN TRANSACTION
UPDATE Cuentas SET Saldo=Saldo – 100.00 WHERE
Clave = 100
UPDATE Cuentas SET Saldo=Saldo + 100.00 WHERE
Clave = 200
COMMIT TRANSACTION
10. Analice el resultado
11. Ahora sólo ejecute sólo las primeras 2 líneas del código anterior que
consta de 4 líneas.
12. Cierre la aplicación con la que introduce los comandos SQL
13. Vuelva a entrar a la aplicación y consulte el contenido de la cuenta.
14. Analice la importancia del manejo de transacciones.
La situación más común en una transacción, es que ésta dure muy poco tiempo,
algunos segundos (3 ó 4 segundos o menos es ideal, pero no una regla); por lo
que la diferencia de tiempo entre una acción y la siguiente es una fracción muy
pequeña de segundo. Este tiempo de transacción se denomina síncrona y son
las que se tratan en este curso.
Por otro lado, puede efectuarse una transacción distribuida a través de los
mecanismos que ofrecen manejadores de bases de datos distribuidas; sin
embargo, este esquema excluye la participación de objetos por lo tanto el
modelo de aplicación que divide la aplicación en capas. Ciertamente se efectúa
la transacción distribuida pero únicamente a nivel de los manejadores de bases
de datos.
Por tal motivo, deben existir Monitores de Transacciones con Objetos que
fungen como servidores de objetos de aplicación. Los cuales disponen los
objetos o componentes hacia los objetos o componentes que solicitan estos
servicios.
A partir de 1980, cada vez más fue requerido los procesos de commit y rollback
en los administradores de bases de datos. Al finales de los 80’s, el requerimiento
de transacción trascendió a ser distribuido con el objetivo de brindar integridad y
consistencia en la información.
En la segunda fase, ya una vez recibida la ejecución de las acciones por los
administradores de recursos quedando pendiente la confirmación local en cada
uno. Se manda la orden de confirmación en todos los administradores de
recursos para que confirmen. Si un administrador de recursos provoca un error,
el administrador de transacciones manda la señal de reversión a los
administradores de recursos que anteriormente habían tenido éxito, cada uno de
estos revierten su transacción local.
3.3. CORBA
CORBA
Escenario
¿Qué es CORBA?
• CORBA es un middeware o marco de trabajo estándar y abierto de
objetos distribuidos que permite a los componentes en la red ínter
operar en un ambiente común sin importar el lenguaje de desarrollo,
sistema operacional, tipo de red, etc.
• En esta arquitectura, los métodos de un objeto remoto pueden ser
invocados de forma transparente en un ambiente distribuido y
heterogéneo a través de un ORB (Object Request Broker).
• Además del objetivo básico de ejecutar simplemente métodos en
objetos remotos, CORBA adiciona un conjunto de servicios que
amplían las potencialidades de éstos objetos y conforman una
infraestructura sólida para el desarrollo de aplicaciones críticas de
negocio.
IDL E DSI
Skeleton
IDL DII ORB
Stubs Interface Object Adapter
ORB
IIOP (Internet Inter ORB Protocol)
Descripción de elementos
• ORB: Provee un mecanismo de interfaz y de comunicación transparente
entre la referencia de un objeto y su implementación. Ofrece los
servicios de localización, establecimiento de la conexión y la transmisión
de llamadas de métodos y valores de retorno.
• IIOP: Protocolo para la comunicación entre ORBs a través de TCP/IP. El
ORB se comunica a través de IIOP sin intervención del desarrollador.
• IDL (Interface Definition Language): Se utiliza para definir la interfaz para
un Objeto CORBA, independiente del leng uaje en que está desarrollado.
Utiliza el mecanismo de stub -skeleton (acopladores).
• Object Adapters: Proveen la implementación de tiempo de ejecución de
las siguientes responsabilidades:
o Generar e interpretar referencias de objetos.
o Invocar métodos.
o Garantizar la seguridad de las aplicaciones.
o Activar y desactivar objetos.
o Enlazar las referencias de objetos con las implementaciones.
Descripción de elementos
o Registrar las implementaciones de objetos.
• DII (Dynamic Invocation Interface): El DII permite al cliente aprender en
tiempo de ejecución las operaciones soportadas por el servidor y crear
solicitudes, sin stub, que son enviadas directamente al ORB.
• DSI (Dynamic Skeleton Interface): Contraparte de DII, permite al servidor
implementar una interfase no conocida en tiempo de ejecución, sin
intervención del Skeleton.
Escenario CORBA
Mediante la técnica de Estudio de Caso, los alumnos realizarán en equipo las
actividades siguientes:
Actividad 3.3
Estudio de Caso CORBA (Escenario CORBA)
Puntos de
Arriba del En el Debajo del
Atributos Atributo
Estándar Estándar Estándar
Obtenidos
(5 -4.5) (4 -3.5) (3-0)
Sus
Participación,
Sus intervenciones
pero sus
intervenciones mostraron
intervenciones
mostraron relación con
no estaban
bastante el escenario,
Definición del relacionadas
relación con pero no
Problema con el
el escenario y lograron
escenario ni
fueron la base aterrizarlas
condujeron
para abordar del todo para
para abordar
el problema. abordar el
el problema.
problema.
(10-9 ) (8.5 -7) (6.5-0)
La La
La
información información
información
revisada revisada
revisada no
permitió a los permitió a los
Aplicación de la permitió a los
estudiantes estudiantes
Información estudiantes
comprender comprender
comprender el
con claridad parcialmente
ejercicio de
el ejercicio de el ejercicio de
algoritmos.
algoritmos. algoritmos.
(5 -4.5) (4 -3.5) (3-0)
Su aportación Hizo
fue bastantes Hizo pocas
determinante aportaciones, aportaciones
Solución/explicación para la pero le falto y sin relación
del problema elaboración aterrizarlas en con las
del reporte propuestas posibles
final de la concretas de soluciones del
solución del solución al problema.
problema. problema.
Total de Puntos Obtenidos
3.3 CORBA
3.3.1 Introducción
Servicios Middleware
Para que un componente pueda ser integrado por terceras partes en sus
sistemas, éste deber ser suficientemente auto contenido y debe proveer una
especificación de lo que requiere y provee. En otras palabras, los componentes
deben encapsular su implementación e interactuar con otros componentes a
través de interfaces bien definidas.
Y al hablar de objetos vale la pena distinguir aquí los objetos de las clases. Una
clase es una definición de propiedades y funcionalidades ha ser provistas por los
objetos. A partir de una clase es posible la instancia objetos. Los componentes
pueden contener una o más clases y serán los clientes de los componentes
quienes soliciten la creación de las instancias de estas clases.
• Crear objetos: ¿Cómo hace el programador para crear una instancia del
objeto Venta? Es necesario que exista un mecanismo para indicar al
componente que cree una instancia del objeto Venta. Una vez creada la
instancia ¿Cómo se logra acceder a sus propiedades o métodos?
Estas son sólo algunas de las cuestiones que el programador tendrá que
resolver para poder utilizar el componente. En el caso de que el programador
llegara a comprar otro componente, es seguro que desea que los mecanismos
de utilización sean uniformes para no tener que resolverlas nuevamente. Los
servicios middleware que provee CORBA buscan resuelven estos problemas.
aplicación comunicarse con otra sin importar el tipo de red, protocolo, sistema
operacional o lenguaje de desarrollo.
El Modelo de Objetos
Semántica de Objetos
Aunque los objetos pueden ser creados o destruidos, desde el punto de vista del
cliente no existen mecanismos especiales para la creación o destrucción.
Tipos
Interfaces
Operaciones
Una Operación es una entidad identificable que denota un servicio que puede
ser requerido. Una operación es identificada por un identificador de operación y
tiene una firma que describe los valores legítimos de los parámetros requeridos
y resultados retornados.
Semántica de ejecución
Atributos
Una Interfaz puede tener atributos. Un atributo puede ser sólo lectura o lectura-
escritura.
Implementación de objetos
Elementos de OMA
Más importante aún, una solución basada en ORB, permite integrar aplicaciones
existentes, simplemente describiendo sus Interfaces en IDL y escribiendo los
"wrappers" que traslada entre el bus esta ndarizado y las Interfaces existentes.
Elementos de un ORB
Stubs y Skeleton IDL: Los stubs y skeleton sirven como “pegante” entre el
cliente y servidor respectivamente y el ORB. Son estáticos y generados en
tiempo de compilación por un compilador IDL el cual transforma las Interfaces
IDL hacia el lenguaje de desarrollo, esto reduce las posibilidades de errores al
generar automáticamente los stubs y skeleton.
Interfaz Skeleton Dinámica (DSI): cumple las mismas funciones de DII pero en
el lado del servidor. Permite que el ORB realice llamadas a una Implementación
de Objeto del cual no se tiene conocimiento de la Interfaz.
Referencias de Objeto
Adaptador de objeto
Basic Object Adapter: define una especificación que puede ser usada por
muchos objetos ORB con implementaciones convencionales. Para este
adaptador, las implementaciones son generalmente programas separados. Esto
permite activar un programa por: método, objeto y compartido para todas las
instancias del tipo de objeto. Si la implementación no esta activa, el BOA
comienza una.
Library Object Adapter: es utilizado por los objetos que tienen
implementaciones de librerías. Este accede el almacenamiento persistente en
archivos y no soporta activación o autenticación, ya que los objetos se asume
que están en los clientes.
Object-Oriented Database Adapter: usa una conexión a una OODB para
proveer acceso a los objetos almacenados. Los objetos pueden ser registrados
implícitamente.
Interfaz ORB
Son las Interfaces que directamente llegan al ORB y que son las mismas para
todas las implementaciones de ORBs y que no depende de la Interfaz de un
objeto o adaptador. Ya que muchas de las funcionalidades del ORB son
provistas a través del adaptador de objetos, stubs, skeleton o invocación
dinámica; quedan pocas operaciones comunes a través de todos los objetos.
Repositorio de Interfaces
Repositorio de implementación
ORB basado en librería: para objetos que son de “peso liviano” y cuyas
implementaciones pueden ser compartidas, la implementación del ORB podría
ser en una librería. En este caso, los stubs pueden ser los métodos reales. Esto
asume, que es posible para un cliente tener acceso a los datos para los objetos
y que la implementación confía en que el cliente no dañara los datos.
Los CORBA Services especifican servicios básicos casi todos los objetos
necesitan.
• Nombres • Persistencia
• Trader • Consulta
• Notificación • Relaciones
• Eventos • Concurrencia
• Transacciones • Externalización
• Seguridad • Licenciamiento
• Ciclo de vida • Tiempo
• Propiedades • Colección
mecanismos, los publicadores pueden generar evento sin tener que conocer la
identificación de sus consumidores y viceversa. Hay dos acercamientos, modelo
Push y modelo Pull, en el modelo Push los publicadores toman la iniciativa de
iniciar la comunicación, en el modelo Pull, los suscriptores requieren eventos de
los publicadores.
Relaciones: permite la definición del papel ejecutado por objetos CORBA en una
relación.
Las facilidades CORBA tanto horizontales como verticales, son diseñadas para
completar la arquitectura entre los Servicios básicos de CORBA y las
aplicaciones específicas de industria. Con una arquitectura completa, las
compañías compartirán datos a nivel de aplicación y funcionalidades para la
integración de diferentes sistemas de información. Las facilidades representan
un punto medio entre una aplicación particular y los servicios y ORB.
• Interfaz de usuario
• Administración de información
• Administración de sistemas
• Administración de tareas
• Objetos de negocio
• Finanzas y seguros
• Comercio Electrónico
• Manufactura
• Salud o Medicina
• Telecomunicaciones
• Transportes
• Investigación de ciencias de la vida
También bajo la OMG pero que no tienen DTF se encuentran dos Grupos de
Interés Especial:
UML define una notación gráfica para cada uno de los siguientes diagramas: de
casos, de uso, de clases, de comportamiento, de implementación incluyendo
diagramas de componentes y de desarrollo.
Las políticas permite tener control de la Calidad del Servicio de las invocaciones,
los clientes y objetos pueden establecer control de ordenación (por tiempo,
prioridad, deadline), configurar prioridades, deadlines y tiempos de vida,
configurar tiempos de inicio y finalización para invocaciones sensibles al tiempo
y controlar las políticas de enrutamiento y número de saltos.
Cuestionario
Escenario
Los programas del CORBA consisten en uno o más clientes y uno o más
servidores.
Los clientes tienen acceso a estos métodos y atributos que usan la Static
Invocation Interface (SII).
module library {
typedef struct _Book {
string isbn;
string title;
string author;
} Book;
typedef sequence<Book> BookList;
interface Library {
readonly attribute string name;
readonly attribute string address;
Book createBook(in string isbn, in string title, in string author);
BookList findBooksByTitle(in string title);
}
}
BookListHelper.java
Ésta es la clase del Auxiliador para el tipo de BookList (secuencia)
BookListHolder.java
Ésta es la clase del Poseedor para el tipo de BookList (secuencia)
Library.java
Ésta es la interfaz para el servicio de la Biblioteca
Esta clase extiende LibraryOperations
LibraryHelper.java
Ésta es la clase del Auxiliador para el tipo de la Biblioteca (interfaz)
LibraryHolder.java
Ésta es la clase del Poseedor para el tipo de la Biblioteca (interfaz)
LibraryOperations.java
Estas son las Operaciones de interfaz para la Biblioteca de interfaz
Esta interfaz define las operaciones en la Biblioteca
LibraryPOA.java
Éste es el POA (o server stub o skeleton) para la interfaz de la Biblioteca
_BookHelper.java
Ésta es la clase del Auxiliador para el tipo del Libro (estructura)
_BookHolder.java
Ésta es la clase del Poseedor para el tipo del Libro (estructura)
_LibraryStub.java
Ésta es la clase de client stub para la interfaz de la Biblioteca
Se usan clases del poseedor cuando un método define los parámetros out o
inout, dado que Java no los soporta nativamente. Ellos almacenan los valores
de los parámetros cuando ellos son pasados a un método (in) y/o después los
métodos regresan (out). Cualquier tipo que se usa como un parámetro (o valor
devuelto) para una operación debe tener una clase del Poseedor para cuando
los parámetros in e inout se usan.
package library;
import java.util.ArrayList;
public class LibraryServiceImpl extends LibraryPOA {
private ArrayList books = null;
public LibraryServiceImpl() {
books = new Arra yList();
_Book book1 = new _Book();
book1.title = "Java: How to Program";
book1.author = "Deitel";
book1.isbn = "123456";
books.add(book1);
_Book book2 = new _Book();
book2.title = "XML for Beginners";
book2.author = "Colouris";
book2.isbn = "234567";
books.add(book2);
_Book book3 = new _Book();
book3.title = "Distributed Systems";
book3.author = "Romero";
book3.isbn = "345678";
books.add(book3);
}
public String name() { return "The U of W Online Library"; }
public String address() { return "401 Sunset Ave."; }
public _Book createBook(String isbn, String title, String author) {
_Book newBook = new _Book();
newBook.title = title;
newBook.isbn = isbn;
newBook.author = autho r;
books.add(newBook);
return newBook;
}
Aquí un ArrayList se usa para almacenar los libros. Ésta es una clase
predeterminada simple en Java que representa una matriz dinámicamente-
dimensionada.
Ahora, debe registrar el servicio con el lookup service. Esto puede hacerse en
la misma clase, pero aquí se implementa separadamente para la demostración.
package library;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import org.omg.PortableServer.*;
public class LibraryRegistrar {
public static void main(String[] args) {
try {
// initialize the ORB
ORB orb = ORB.init(args, null);
// create an instance of the service implementatio n
LibraryServiceImpl service = new LibraryServiceImpl();
// get a reference to the root POA
org.omg.CORBA.Object rootPOARef =
orb.resolve_initial_references("RootPOA");
POA rootPOA = POAHelper.narrow(rootPOARef);
Cliente
package libraryclient;
import library.*;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
public class LibraryClient {
public static void main(String args[]) {
try {
// create and initialize the ORB
ORB orb = ORB.init(args, null);
// get an object reference to the
// Naming service
org.omg.CORBA.Object namingRef =
orb.resolve_initial_references("NameService");
NamingContextExt naming =
NamingContextExtHelper.narrow(namingRef);
Compilación
Cree un directorio en su sistema para este ejemplo. Este directorio será llamado
~/corba_tutorial. Debe reemplazar este nombre de directorio con el directorio
que ha creado. Cree los directorios para el cliente y repare, como sigue:
mkdir ~/CORBA/client
mkdir ~/CORBA/service
cd ~/CORBA/service
idlj –fall library.idl
El compilador idlj creará un directorio llamado ' library', dado que éste es el
nombre del módulo en el archivo de IDL que fue convertido en un paquete
cuando el IDL se mapeo a sus Java bindings. Por consistencia, se han puesto
también el servicio y archivos del registrador en este mismo paquete. Por
consiguiente, copie el servicio y código del registrador en los archivos
apropiadamente nombrados (LibraryServiceImpl.java y LibraryRegistrar.java,
respectivamente) en el directorio ~/corba_tutorial/service/library. Compile todos
los archivos en este directorio:
javac library/*.java
mkdir ~/CORBA/client/libraryclient
mkdir ~/CORBA/client/library
cd ~/CORBA
cp service/library/BookHelper.class client/library
cp service/library/BookListHelper.class client/library
cp service/library/Library.class client/library
cp service/library/LibraryHelper.class client/library
cp service/library/LibraryOperations.class client/library
cp service/library/_Book.class client/library
cp service/library/_BookHelper.class client/library
cp service/library/_LibraryStub.class client/library
cd ~/CORBA/client
javac libraryclient/LibraryClient.java
Ejecución
El servicio y cliente están ahora listos para ejecutar. La primera cosa para hacer
es empezar un servicio de nombres, para que el registrador pueda registrar el
servicio cuando ejecuta. Esto debe hacerse antes que el registrador ejecute.
cd ~/CORBA/service
java library.LibraryRegistrar –ORBInitialPort 1050 –ORBInitialHost localhost
cd ~/CORBA/client
java libraryclient.LibraryClient –ORBInitialPort 1050 –ORBInitialHost Localhost
Está ahora listo para escribir un simple cliente/servicio CORBA. Mucho del
código en el ejemplo anterior puede ser considerado una plantilla del CORBA
estándar. Puede identificar la mayoría de este código dado que esta
documentado.
3.4. RMI
Escenario RMI
¿Qué es RMI?
Arquitectura RMI
Registro de
Objetos
Soporta la
interfase con
Cliente del Servidor del
el programa Objeto Objeto
de aplicación
Stub Skeleton
Mapea la plataforma
independiente de la capa Capa de Referencia Remota
Stub/Skeleton a la
plataforma dependiente Capa de Transporte
de la capa de transporte,
moviliza los protocolos de
referencia remota
Activa, mantiene y
desactiva las
conexiones, y
moviliza el
protocolo de
transporte
Escenario RMI
Definir su interfaz
remota 1
4 rmic
Server class (.class)
Implemente Client stub (.class) Server Skeleton (.class)
8 el cliente
Actividad 3.4
Actividad RMI
Ejercicio RMI
EJERCICIO
import java.rmi.server.*;
try {
/* Constructor */
public HelloServer() {
start ClienteHola
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9) (8.5-7) (6.5-0)
La información La información La información
revisada permitió a revisada permitió revisada no
los estudiantes a los estudiantes permitió a los
Aplicación de
comprender con comprender estudiantes
la Información
claridad los solamente los comprender los
ejercicios y ejercicios y ejercicios y
programas. programas. programas.
(10-9) (8.5-7) (6.5-0)
Los estudiantes han
demostrado el Los estudiantes
Los estudiantes no han hecho
significado del han demostrado
contacto con el
material elaborando el significado del
material,
Conexiones correctamente, material
Especialistas mientras extienden simplemente sin
incorporándolo
incorporar la
y explican la correctamente en
información en
información, el estudio del
su estudio del
incorporándola en el tema. tema.
estudio del tema.
Total de Puntos Obtenidos
3.5. COM+
Escenario COM+
.Net y COM+
Capacidades de COM+
Se anexa material de apoyo para el tema de COM+, que se extiende por las
capacidades que presenta COM+, por lo que deberá realizar las actividades
siguientes:
• Resolver los cuestionarios del material de apoyo 3.5
• Realizar los ejercicios del material de apoyo 3.5
Actividad 3.5
Actividad COM+
Contestar los cuestionarios y realizar los ejercicios del Material de Apoyo 3.5.
Coloque el informe de su actividad en Tarea Individual 3.5
3.5. COM+
3.5.1. Introducción a los Servicios COM+
Introducción
Componentes de software
Para comprender COM+, resulta útil comprender la evolución de COM, así como
los servicios de colas de transacciones y de mensajes. Está sección proporciona
una introducción a estas tres tecnologías antes de explicar sus mejoras en
COM+.
Con Windows Server, estos servicios se han integrado y refinado aún más para
permitir a los programadores escribir software basado en componentes
complejos con menor cantidad de código personalizado.
Para hacer posible la creación de aplicaciones distribuidas, tiene que haber una
manera de separar la aplicación en pilares más pequeños encargados de
funciones específicas. Además, estos pilares deben ser capaces de ejecutarse
en un único proceso, en varios procesos diferentes e incluso en máquinas
diferentes, de ahí el nombre distribuido. COM cumple estos requisitos previos,
además de proporcionar estos requisitos adicionales:
Una vez que COM se popularizó, los programadores se dieron cuenta de que
necesitaban que los componentes pudieran funcionar juntos a través de las
redes. Por esa razón, con Windows NT Server 4.0 Microsoft presentó el Modelo
de objetos componentes distribuido (DCOM), que amplía COM para que la
tecnología de componentes pueda funcionar a través de redes y de Internet,
como sucede en una arquitectura de n niveles. Desde su presentación, se ha
utilizado con frecuencia el término COM para incluir también las tecnologías
distribuidas DCOM.
Servicios de transacciones
Servicios de transacciones
Por ejemplo, el proceso utilizaría una base de datos con información de clientes
para registrar el nombre y la dirección del cliente, una base de datos de
inventario para asegurarse de que hay disponibilidad del producto para atender
el pedido, una base de datos de envío para realizar el seguimiento del envío y
un proceso de comprobación de crédito para asegurarse de que la tarjeta de
crédito del cliente es válida.
Como puede no ser necesario completar todos los pasos del proceso de una
aplicación a la vez, muchas aplicaciones distribuidas necesitan poder controlar
los retardos entre una solicitud y su respuesta. En estas situaciones se utilizan
los Servicios de Message Queue Server (MSMQ). MSMQ es una tecnología
independiente que complementa las capacidades inherentes a COM y MTS.
MSMQ permite a las aplicaciones utilizar componentes que se comunican entre
sí de forma asincrónica mediante mensajes en cola, que es un concepto similar
al de un mensaje de correo electrónico que espera en una bandeja de entrada.
Por ejemplo, un programador puede utilizar MSMQ para escribir una aplicación
que permitirá a los clientes realizar pedidos a través de Internet, incluso si el
servidor Web encargado de la recepción no está disponible. Las colas de
mensajes también pueden utilizarse para realizar procesos de fondo más
eficaces. Por ejemplo, cuando un cliente realiza un pedido, no es necesario
procesar todos los componentes del pedido inmediatamente. En el ejemplo
descrito anteriormente, el departamento de envío no tiene que recibir el pedido
del cliente hasta que se haya completado el resto de la transacción. Con MSMQ,
la aplicación de entrada de pedidos puede seguir ejecutándose incluso si la
aplicación de envíos no está disponible.
COM+
COM+
Introducción
(CLR) y una sintaxis de codificación mucho más sencilla. Se puede tener acceso
a la infraestructura de servicios de COM+ desde código administrado y no
administrado. Los servicios en código no administrado se conocen como
servicios de COM+. En .NET se hace referencia a estos servicios como
Enterprise Services o servicios empresariales. Derivar una clase de
ServicedComponent indica que los servicios los solicitará un componente. (Si un
componente no necesitara los servicios, no debería derivar de
ServicedComponent.) La compatibilidad de herramientas se ha mejorado para
permitir a los programadores escribir aplicaciones basadas en el servidor,
aunque la escalabilidad y el rendimiento aún pertenecen al campo de las
prácticas de programación. La idea básica que subyace en los servicios es
diseño para el rendimiento y la escalabilidad desde el exterior y
aprovechamiento de los Enterprise Services para una fácil implementación de
dichos patrones de diseño donde sea necesario.
System.EnterpriseServices.ServicedComponent
Los servicios pueden fluir también entre objetos de COM+ y .NET Framework.
Cada entorno controla la implementación y ejecución de su código nativo; COM+
proporciona siempre el contexto del objeto.
La activación justo -a-tiempo (JIT) es el mecanismo usado por COM+ para evitar
el consumo de recursos por parte de los componentes mientras éstos están en
estado “ocioso”, es decir, el desarrollador puede instanciar sus objetos COM+ al
principio de su programa y dejarse de preocupar acerca del consumo de estos
ya que solo son activados cuando alguno de los métodos es llamado.
• Transaction
• ObjectPooling
• JustInTimeActivation
• EventClass
• ApplicationActivation
Para demostrar los componentes servidos, crearemos una clase que encapsula
la funcionalidad de la aplicación COM+ y crearemos un formulario para proveer
una interfaz gráfica desde el cual se harán las llamadas. A diferencia de otro
ensamblado de .NET estos requieren un tratamiento especial. A continuación se
muestra el conjunto de atributos del archivo AssemblyInfo.cs que han de ser
agregados para que nuestra aplicación pueda funcionar correctamente
(AssemblyInfo.cs del proyecto clsPruebaDeComPlus)
[assembly: ApplicationActivation(ActivationOption.Server)]
[assembly: ApplicationAccessControl(false)]
[assembly: ApplicationID("448934a3-324f-34d3-2343-129ab3c43b2c")]
[assembly: ApplicationName("DemoComponenteServido")]
[assembly: Description ("Demostración de COM+ en .NET")]
El primer atributo especifica el tipo de aplicación que es (en este caso esta será
de tipo biblioteca) esta información corresponde a la enumeración de
ActivationOption. El segundo atributo es la manera como se accede al control de
Gacutil -I ensamblado.dll
Una vez hecho esto procedemos a probar nuestro aplicación COM+. Como se
muestra a continuación el registro de la aplicación fue exitoso.
Cada vez que se pulse el botón ejecutar query de nuestro formulario (cliente) se
podrá apreciar como se activan las barras de transaccio nes activas y se
incrementa la barra de transacciones ejecutadas. Aunque en este artículo solo
recuperamos información la misma técnica aplica para operaciones que tengan
que ver con manipulación (modificación) de la data.
Cuestionario
4. ¿Qué es el contexto?
5. ¿Qué es ServicedComponent?
Basta con que un solo participante no pueda garantizar este punto para que la
transacción falle en su totalidad. Todos los cambios efectuados en datos dentro
del ámbito de la transacción se deshacen hasta un punto específico establecido.
Propiedades ACID
Atomicidad
Coherencia
Aislamiento
El aislamiento requiere que parezca que cada transacción sea la única que
manipula el almacén de datos, aunque se puedan estar ejecutando otras
transacciones al mismo tiempo. Una transacción nunca debe ver las fases
intermedias de otra transacción.
Permanencia
Transacciones distribuidas
Administradores de transacciones
En una transacción distribuida, cada recurso participante tiene un administrador
de transacciones (TM) local para efectuar el seguimiento de las transacciones
entrantes y salientes en el equipo. El supervisor TP asigna a un TM la tarea
adicional de coordinar todas las actividades entre TM locales. El TM que
coordina las actividades de transacción recibe el nombre de TM principal o
coordinador.
Administradores de recursos
Un administrador de recursos es un servicio de sistema que administra datos
persistentes o permanentes en bases de datos, colas de mensajes permanentes
o sistemas de archivos transaccionales. El administrador de recursos almacena
datos y realiza su recuperación ante un error del sistema.
Dispensadores de recursos
Un dispensador de recursos administra los estados no permanentes que pueden
aparecer en las transacciones. Por ejemplo, el dispensador de recursos de Open
Database Connectivity (ODBC) administra grupos de conexiones de bases de
datos, reclamando cada conexión cuando deja de ser necesaria.
Hay una serie de pasos que se deben seguir para obtener un componente .NET
que funcione con servicios COM+. Para empezar, debemos crear una clase que
se derive de la clase System.EnterpriseServices.ServicedComponent. Esta clase
de base proporciona todos las propiedades y los métodos necesarios para
interactuar con los servicios COM+. Deberemos marcar la clase para que
requiera una nueva transacción y los métodos creados para que puedan
completar la transacción automáticamente si no se producen errores. Vamos a
ponerlo en práctica:
Imports System.EnterpriseServices
Imports System.Reflection
'********************************************
'Detalles de registro de COM+
<TransactionAttribute(TransactionOption.Required)> _
Public Class COMPlusServices
Inherits ServicedComponent
Este código empieza importando un par de espacios de nombre para tener que
escribir menos al declarar componentes.
<Assembly: _ AssemblyKeyFileAttribute("bin/ComPlusExample.snk")>
Este código indica al catálogo COM+ la ubicación del nombre seguro. El archivo
.SNK, que crearemos más tarde, es el que describe el componente para COM+.
<TransactionAttribute(TransactionOption.Required)> _
Public Public Class COMPlusServices
El atributo junto a este nombre de clase indica a COM+ que desea definir el
atributo de transacción como Necesario. Agregar esta línea de código es lo
mismo que abrir el complemento de aplicaciones COM+ y definir este atributo de
forma manual, como se muestra en la figura de la sección anterior.
Inherits ServicedComponent
Si no incluye esta línea, no podrá hacer que funcione este componente bajo
COM+.
Una vez que la configuración de esta clase se haya completado, puede crear un
método que efectúe alguna acción. La función DoTransaction en el código
sn -k ComPlusExample.snk
Ahora necesitará compilar este programa para generar los archivos necesarios y
registrar este componente con COM+. En Visual Studio .NET, en el menú
Generar, haga clic en Generar.
Module modMain
Sub Main()
Dim objCOMPlus As New _
COMPlusJumpStart.COMPlusServices()
Console.WriteLine(objCOMPlus.DoTransaction)
Console.ReadLine()
End Sub
End Module
Prueba
Cuestionario
1. Nombre las cuatro propiedades ACID de transacciones.
El nivel de seguridad
ApplicationAccessControl.
[assembly: ApplicationAccessControl(true,
AccessCheckLevel=AccessChecksLevelOption.ApplicationComponent)]
// agrega NTAuthority\everyone a esta función
[assembly:SecurityRole("TestRole1",true)]
// agrega usuarios a las funciones administrativamente
[assembly:SecurityRole("TestRole2")]
Configuración de RBS a nivel de clase en metadatos:
[assembly: ApplicationAccessControl(true,
AccessCheckLevel=AccessChecksLevelOption.ApplicationComponent)]
…
[ComponentAccessControl()]
[SecurityRole ("TestRole2")]
public class Foo : ServicedComponent
{
public void Method1() {}
}
[assembly: ApplicationAccessControl(true,
AccessCheckLevel=AccessChecksLevelOption.ApplicationComponent)]
Interface IFoo
{
void Method1();
void Method2();
}
[ComponentAccessControl()]
[SecureMethod]
public class Foo : ServicedComponent, IFoo
{
// Agregar funciones a este método administrativamente
public void Method1() {}
// "RoleX" se agrega al catálogo para este método
SecurityRole("RoleX")
public void Method2() {}
}
[assembly: ApplicationAccessControl(true,
AccessCheckLevel=AccessChecksLevelOption.ApplicationComponent)]
Interface IFoo
{
void Method1();
void Method2();
}
[ComponentAccessControl()]
public class Foo : ServicedComponent, IFoo
{
// Agregar funciones a este método administrativamente
[SecureMethod] // O utilizar SecurityRole (se traduce en
SecureMethod++)
public void Method1() {}
public void Method2() {}
}
'********************************************
'Detalles de registro de COM+
'Atributo de seguridad basada en funciones
Desde el menú Generar de Visual Studio .NET, haga clic en Volver a generar
solución.
Prueba
Sub Main()
Dim objCOMPlus As New _
COMPlusJumpStart.COMPlusServices()
Console.WriteLine(objCOMPlus.DoTransaction)
Console.WriteLine(objCOMPlus.IsManager().ToString)
Console.ReadLine()
End Sub
Sub Main()
Try
Dim objCOMPlus As New _ COMPlusJumpStart.COMPlusServices()
Console.WriteLine(objCOMPlus.DoTransaction)
Console.WriteLine(objCOMPlus.IsManager().ToString)
Console.ReadLine()
Catch objException As Exception
Console.WriteLine("Se produjo un error. " _ & "Detalles: "
_&objException.Message)
Console.ReadLine()
End Try
End Sub
Autenticación
Autorización
Protección de datos
La protección de datos es el proceso que consiste en proporcionar
confidencialidad, integridad y no repudio a los datos. Los datos requieren
protección no sólo cuando están en tránsito sino también cuando están
Dado que la clave de cifrado determina el rigor del cifrado, todos los algoritmos
de cifrado son vulnerables a los ataques por fuerza bruta. Estos ataques
consisten en el intento sistemático de descifrar los datos utilizando todas las
claves posibles. Por ejemplo, si la clave de cifrado utilizada para cifrar los datos
sólo se compone de cuatro bits, para que se produzca un ataque por fuerza
bruta que afecte a los datos sólo tienen que probarse hasta dieciséis valores de
clave de cifrado. Para obtener más información, vea Criptografía.
La integridad de los datos se obtiene mediante algoritmos hash, firmas digitales
y códigos de autenticación de mensajes.
La firma digital va un paso más allá del simple cálculo del hash y cifra el hash
calculado utilizando una clave privada. Este paso adicional puede impedir que
un atacante intercepte los datos y el hash que los acompaña, modifique los
datos y, después, simplemente vuelva a calcular el nuevo hash de los datos
modificados. Como una firma digital es un hash cifrado, el atacante necesitaría
obtener acceso a la clave privada original utilizada para crear la firma digital
original. Las firmas digitales pueden verificarse en el receptor final mediante la
clave pública asociada. Las firmas digitales pueden utilizarse para exigir la no
repudiación de los datos, que puede utilizarse más adelante para comprobar el
origen, contenido y marca de hora de los datos. Para obtener más información,
vea Algoritmos hash y firmas digitales.
Auditoría
Cuestionario
[Visual Basic]
<ApplicationQueuingAttribute(QueueListenerEnabled := _
true, MaxListenerThreads := 64 )>
[C#]
[ApplicationQueuingAttribute(QueueListenerEnabled = true, MaxListenerThreads
= 64 )]
Servidor
[Visual Basic]
Imports System.Reflection
Imports System.EnterpriseServices
Imports System
<assembly: A pplicationName("QCDemoSvr")>
<assembly: ApplicationActivation(ActivationOption.Server)>
<assembly: ApplicationQueuing(Enabled := True, _
QueueListenerEnabled := True)>
<assembly: AssemblyKeyFile("QCDemoSvr.snk")>
Namespace QCDemo
Public Interface IQComponent
Sub DisplayMessage(msg As String)
End Interface
<InterfaceQueuing(Interface := "IQComponent")> _
Public Class QComponent
Inherits ServicedComponent Implements IQComponent
Public Sub DisplayMessage(msg As String) implements _
IQComponent.DisplayMessage
MessageBox.Show(msg, "Processing message")
End Sub 'DisplayMessage
End Class
End Namespace
[C#]
using System.Reflection;
using System.EnterpriseServices;
[assembly: ApplicationName("QCDemoSvr")]
[assembly: ApplicationActivation(ActivationOption.Server)]
[assembly: ApplicationQueuing(Enabled=true, QueueListenerEnabled=true)]
[assembly: AssemblyKeyFile("QCDemoSvr.snk")]
namespace QCDemo
{
public interface IQComponent
{
void DisplayMessage(string msg);
}
[InterfaceQueuing(Interface = "IQComponent"]
public class QComponent : ServicedComponent, IQComponent
{
public void DisplayMessage(string msg)
{
MessageBox.Show(msg, "Processing message");
}
}
}
Client
[Visual Basic]
Protected Sub Send_Click(sender As Object, e As System.EventArgs) _
Handles send.Click
Dim iQc As IQComponent = Nothing
Try
iQc =
CType(Marshal.BindToMoniker("que ue:/new:QCDemo.QComponent"), _
IQComponent)
Catch l as Exception
Console.Writeline("Caught Exception: " & l.Message)
End Try
iQc.DisplayMessage(messageToSend.Text)
Marshal.ReleaseComObject(iQc)
End Sub 'Send_Click
[C#]
protected void Send_Click (object sender, System.EventArgs e)
{
IQComponent iQc = null;
try
{
iQc = (IQComponent)
Marshal.BindToMoniker("queue:/new:QCDemo.QComponent");
}
catch
{
MessageBox.Show("Cannot create Queued Component");
}
iQc.DisplayMessage (messageToSend.Text);
Marshal.ReleaseComObject(iQc);
}
'********************************************
'Detalles de registro de COM+
<Assembly: ApplicationActivationAttribute(ActivationOption.Server)>
'********************************************
'Detalles de registro de COM+
Prueba
Sub Main()
Dim objTest As COMPlusJumpStart.COMPlusServices
Dim strMoniker
strMoniker = _ "queue:/new:COMPlusJumpStart.COMPlusServices"
objTest = GetObject(strMoniker)
objTest.QueueTest()
End Sub
Cuestionario
3. Liste dos factores que representen que una interfaz es impropia para la
operación en cola.
De MTS a COM+
El archivo .msi que contiene una aplicación COM+ sólo puede ser instalado en
equipos que admitan Servicios COM+ 1.0 (en la actualidad, sólo Windows 2000).
Como ventaja adicional, las aplicaciones COM+ que utilizan Windows Installer
aparecen en el panel de contro l de Agregar o quitar programas, a menos que se
modifique el archivo .msi mediante una herramienta de edición de Windows
Installer.
Para tener acceso a una aplicación de servidor COM+ remotamente desde otro
equipo (cliente), el equipo cliente debe tener un subconjunto de atributos de la
aplicación del servidor que se haya instalado, incluidas bibliotecas DLL de proxy
o código auxiliar, y bibliotecas DLL y de tipos destinadas al uso remoto de la
interfaz DCOM. Este subconjunto recibe el nombre de proxy de aplicación.
La labor del administrador del sistema es poblar las funciones que define la
aplicación con los grupos y las cuentas de usuario de Windows 2000. Esta es
una fase crucial en la aplicación de la directiva de seguridad de la aplicación. Se
deben asignar los usuarios a las funciones que representan correctamente sus
relaciones con los datos y recursos a los que podrían tener acceso a través de la
aplicación.
La mejor forma de poblar estas funciones con usuarios es utilizar los grupos de
Windows 2000. En primer lugar, se asigna una cuenta de usuario a los grupos
en cuestión y, después, se asegura que a estos grupos se les asignan las
funciones adecuadas. El uso de los grupos de Windows 2000 para poblar
funciones le facilita la administración de grandes cantidades de usuarios.
aplicaciones, esta tarea se vuelve cada vez más complicada. La solución más
escalable es la de asignar grupos de us uarios a las funciones de la aplicación
COM+.
Agrupación de objetos
Cuando el grupo alcanza su nivel máximo, las solicitudes del cliente entran en la
cola de trabajo. Cada solicitud recibe el primer objeto disponible del grupo. El
número de objetos, tanto activados como desactivados, no sobrepasará nunca el
valor máximo del grupo. El tiempo de espera de las solicitudes de creación de
objetos se agotará después de un período especificado administrativamente, de
modo que usted pueda controlar el tiempo que tienen que esperar los clientes
para la creación de objetos. Siempre que sea posible, COM+ intentará reutilizar
un objeto una vez que el cliente lo libere, hasta que el grupo alcance su nivel
máximo.
Puede utilizar el tamaño máximo de grupo para precisar con mucha exactitud el
modo en que utiliza los recursos. Por ejemplo, si tiene licencia para un cierto
número de conexiones de base de datos, puede controlar cuántas conexiones
tiene abiertas en cualquier momento.
Cuestionario
2. ¿Cuáles son los contenidos del archivo .msi que se crea cuándo exporta
una aplicación COM+?
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9 ) (8.5-7) (6.5-0)
La información
La información La información
revisada
revisada permitió revisada no
permitió a los
Aplicación de a los estudiantes permitió a los
la estudiantes
comprender con estudiantes
comprender
Información claridad los comprender
solamente los
ejercicios y los ejercicios y
ejercicios y
programas. programas.
programas.
(10-9 ) (8.5-7) (6.5-0)
Los estudiantes
han demostrado
Los
el significado del
Los estudiantes estudiantes no
material
han demostrado han hecho
elaborando
el significado del contacto con
correctamente,
Conexiones material el material,
mientras
Especialistas incorporándolo simplemente
extienden y
correctamente sin incorporar
explican la
en el estudio del la información
información, en su estudio
tema.
incorporándola en
del tema.
el estudio del
tema.
Total de Puntos Obtenidos
Paso1: Un servicio Web desde un punto de vista del servidor IIS funciona
exactamente igual que una aplicación Web. Se aloja en un directorio virtual y
utiliza para su funcionamiento archivos .ASMX, en vez de las páginas .ASPX
que utilizamos en ASP .NET.
{
public wsdemo()
{}
[WebMethod]
Public Function LlamadaMetodoWSdemo() As String
{
return "Respuesta a wsdemo";
}
}
}
Actividad 3.6
Actividad Web Services
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9 ) (8.5-7) (6.5-0)
La información
La información La información
revisada
revisada permitió revisada no
permitió a los
Aplicación de a los estudiantes permitió a los
estudiantes
la comprender con estudia ntes
comprender
Informació n claridad los comprender
solamente los
ejercicios y los ejercicios y
ejercicios y
programas. programas.
programas.
(10-9 ) (8.5-7) (6.5-0)
Los estudiantes
han demostrado
Los
el significado del
Los estudiantes estudiantes no
material
han demostrado han hecho
elaborando
el significado del contacto con
correctamente,
Conexiones material el material,
Especialistas mientras
incorporándolo simplemente
extienden y
correctamente sin incorporar
explican la
en el estudio del la información
información,
tema. en su estudio
incorporándola en
del tema.
el estudio del
tema.
Total de Puntos Obtenidos
4. Lenguajes de Programación
4.1. Lenguajes y Plataformas de Desarrollo
Actividad 4.1
4.1.1 Antecedentes
Orientado a Procedimiento
Orientada a Objetos
SUN
Máquinas Virtuales
RMI
RMI fue el primer framework para crear sistemas distribuidos que apareció para
Java. Además, viene integrado en cualquier máquina virtual Java posterior a la
1.0 y está pensado para hacer fácil la creación de sistemas distribuidos a partir
de una aplicación cuyas clases ya estén implementadas.
4.1.4 CORBA.
Ventajas
Disponibilidad y Versatilidad
Eficiencia
Inconvenientes
Complejidad
1. Hay que usar un compilador que traduce una serie de tipos de datos
estándares a los tipos del lenguaje en el que se vaya a programar (IDL).
2. Hay que ser conscientes a la hora de diseñar qué objetos van a ser
remotos y cuáles no (los remotos sufren restricciones en cuanto a sus
capacidades con respecto a un objeto normal).
Los ORBs.
El IDL
Gestión de la concurrencia.
Servicio de nombrado.
En CORBA hay varias formas de que un objeto situado en una máquina pueda
referirse a otro remoto.
IOR
Asignación de Nombres
Dándole previamente un nombre al objeto, otro que quiera usar sus servicios
podría emplear una notación tipo URL como
iiop://nombre_host:puerto/nombre_objeto6. Así, si en máquina.inf.uniovi.es,
existe el objeto dns, cualquiera que quiera acceder a dns sólo tiene que solicitar
a su ORB una referencia a iiop://máquina.inf.uniovi.es/dns. Esta forma de
nombrado es más fácil de recordar para la mayor parte de los seres humanos,
aunque seremos nosotros los que tendremos que asegurarnos de su unicidad
(aunque solo dentro de los límites de la máquina en la que se registre).
Seguridad.
2. Los objetos remotos se pueden usar por referencia, pero no por valor. Así,
cuando se haga uso de los métodos de un objeto remoto (al que se accede
por referencia), solo se le pueden pasar como parámetros (y el método solo
podrá devolver como resultado) tipos de datos contemplados en el IDL.
Afortunadamente, este problema queda resuelto con CORBA 3, que sí
soporta el paso de parámetros por valor.
4.1.5 RMI
Gestión de la concurrencia.
Servicio de nombrado.
RMI soporta que objetos clientes puedan emplear objetos remotos por valor y
por referencia. El uso de un objeto remoto por referencia no es nada nuevo,
cualquier objeto expo rtado ante el RMIRegistry se pasa automáticamente por
referencia a cualquier cliente que quiera usarlo.
Seguridad.
Por defecto, RMI no incluye ninguna facilidad para restringir el uso de las clases
desde clientes no autorizados, aunque el usuario siempre puede suplir parte de
esta funcionalidad usando los servicios del sistema operativo, o haciendo ese
4.1.6 DCOM/COM/COM+
Es mejor considerar COM y DCOM como una sola tecnología que provee un
rango de servicios a la interacción del componente, de servicios que promueven
la integración del componente en una sola plataforma, a la interacción del
componente por las redes heterogéneas. De hecho, se unen COM y sus
extensiones de DCOM en un solo tiempo de ejecución. Este solo tiempo de
ejecución proporciona cercanía y acceso remoto.
MTS extiende las capacidades del COM con servicios como transacción y
seguridad. COM+ es la evolución de COM. COM+ integra servicios de MTS y
mensaje en cola en COM y hace COM que se programa más fácil a través de
una integración más íntima con lenguajes de Microsoft como Visual Basic, Visual
C++ y J++.
Asimismo, OMG y Sun están trabajando para hacer que CORBA y RMI sean
interoperables de manera transparente al programador y al usuario. Además, la
plataforma Java 2 viene con soporte de RMI y de CORBA simultáneamente.
Introducción
Alrededor de IIOP.NET
Usando IIOP.NET casi es tan simple como usando el remoto .NET predefinido.
La aplicación siguiente le mostrará cómo tener acceso a un Java EJB desde un
servicio cliente de .NET, usando IIOP.NET. Se selecciono IIOP.NET porque es
libre, actualmente disponible y tiene una herramienta para generar el IDL
automáticamente.
Escenario
Para mostrar cómo tener acceso a un EJB desde .NET, usaremos un simple
ejemplo pero no trivial: un servicio de charla. El servicio es un EJB que permite
usuarios para registrar y eliminar un oyente por recibir los mensajes sometidos
en la sala de conversación; el EJB gestiona la lista de clientes y despacha los
mensajes a todos los clientes registrados. En seguida las interfaces y clases de
Java se usan para comunicar con el servicio; ellas deben ser convertidas a los
archivos de IDL para permitir el acceso de otros clientes de CORBA.
Antes de construir IIOP.NET, copie los archivos lib\ir.idl y lib\orb.idl del directorio
Java SDK en el directorio IDL IIOP.NET y establezca el entorno de variable
WAS_HOME para el directorio de aplicación de servidor de WebSphere.
Compile todo mediante nmake.
listeners[i].notifyMessage(msg);
} catch (Exception e) {
System.err.println("error sending msg: " + e);
System.err.println("--> removing listener");
server.removeListener(listeners[i]);
}
}
}
}
}
¿Por qué el generador crea un netmodule en lugar de un stub de C#? Bien, hay
unas razones, pero los más importantes son la simplicidad y portabilidad.
Primero, los netmodules son bastante fáciles de generar usando la interfaz de
reflexión emitada de .NET; el código fuente generador requeriría algún algoritmo
pretty-printing. Segundo, los netmodules contienen las definiciones en la forma
CLS, lo cual se entiende por todos los lenguajes conforme a .NET, así no le
importa si su código está en C# o Visual Basic.
using System;
namespace ch.elca.iiop.demo.ejbChatroom {
///<SUMMARY>
/// Implementation of the CORBA value type Message
/// </SUMMARY>
El cliente proporciona una interfaz del usuario para coleccionar los mensajes del
usuario, invoque el servicio y despliegue la información enviada por el servicio.
Un simple GUI es utilizado; independientemente de la interfaz del usuario, hay
unas cosas importantes para hacer. Primero, registre el canal IIOP.NET, conecte
al EJB y consigue un caso del servicio.
Para poder recibir los mensajes, el cliente debe registrar a un oyente, es decir un
objeto remoto que implementa la interfaz MessageListener.
Este código realiza una invocación del método sincrónico, es decir espera para
el servidor para completar la difusión y retorno. Sin embargo, esto no es
obligatorio, como los regresos de llamada no resultan y el cliente no tiene la
necesidad de sincronizar con el servidor. Así, una invocación asincrónica
también es posible:
El método oyente notifyMessage() se llamará por los servicios EJB siempre que
un nuevo mensaje esté disponible. Este método lleva a cabo el proceso de
llamadas entrantes por el cliente.
Actividad 4.2
Desarrollo de un Proyecto Final
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9) (8.5 -7) (6.5-0)
El producto final La
Trabajo en equipo
del equipo ha presentación es
con asignación de
sido compartido el resultado del
roles y todos se
Colaboración con todo el esfuerzo de un
esfuerzan en
equipo y grupo, pero
llevar a cabo sus
representa algo solamente han
responsabilidades.
que habría sido contribuido
5. Computación Móvil
Actividades Computación Móvil
Revisar el Material de Apoyo 5 y realizar las tareas siguientes:
1. Realizar un mapa mental por cada uno de los rubros siguientes sobre
computación móvil:
1.1 Antecedentes
1.2 Paradigmas
1.3 Lenguajes y Ambientes de Programación
Nota: Si no cuenta con software para mapas mentales, puede realizarlos a mano
y enviar escaneados.
Los sistemas distribuidos utilizan redes de área local, redes de área extendida e
interredes para comunicarse. Los cambios en las necesidades de los usuarios
han producido la irrupción de las redes inalámbricas.
La tecnología inalámbrica es una de las más prometedoras y discutidas en esta
década para poder comunicar computadoras. La conexión de computadoras
mediante Ondas de Radio o Luz Infrarroja, actualmente está siendo
ampliamente investigada. Las Redes Inalámbricas facilitan la operación en
lugares donde la computadora no puede permanecer en un solo lugar, como en
almacenes o en oficinas que se encuentren en varios pisos. Pero la realidad es
que esta tecnología está todavía en pañales y se deben de resolver varios
obstáculos técnicos y de regulación antes de que las redes inalámbricas sean
utilizadas de una manera general en los sistemas de cómputo de la actualidad.
Sin embargo el estudio sistemático de los mecanismos y las condiciones que los
favorecen, ha permitido el uso confiable de la propagación de ondas de radio en
el espacio para comunicaciones de largo alcance. A pesar de las muchas
variables y factores que tienden a degradar la calidad de las comunicaciones
obtenidas, los ingenieros de comunicaciones han desarrollado técnicas tales
como la diversidad espacial y de frecuencia, que mejoran considerablemente la
confiabilidad y calidad de las transmisiones por ondas de radio.
El ancho de banda se suele asimilar al diámetro de una tubería que sirviese para
canalizar el flujo de datos. Pero esa simplificación es excesiva. De entrada el
ancho de banda es la capacidad de una línea para transmitir información.
Si bien, tanto las señales CC como las CA se pueden emplear para transmitir
flujos de información digital, el modo CA se utiliza para transmisión de larga
distancia.
La Red Telefónica está diseñada para transmitir la voz, que es una señal con un
ancho de banda pequeño. Para obtener suficiente fidelidad en la voz, se
requiere un espectro de frecuencia de 300 Hz a 3,300 Hz. Este espectro de
frecuencia de los circuitos limita el número de bits por segundo, alcanzable. Los
factores que limitan la capacidad de transmisión son el ancho de banda, la
potencia de la señal y el ruido en el conductor.
Modos de Transmisión
El modo Banda Base utiliza todo el ancho de banda, por tanto en un instante
dado sólo puede transmitir una señal. En este modo de transmisión, la señal no
es modulada, no es adecuada para la transmisión a largas distancias, ni para
instalaciones sometidas a nivel alto de ruidos e interferencias.
Fuente: COFETEL
Como Se Modula
donde:
A es la amplitud de la portadora (voltios)
w es la frecuencia angular de la portadora (rad/seg)
@ es el ángulo de fase de la portadora (rad)
Tipos De Modulación
Depende del medio o canal, ya que hay unos mejores que otros, aunque
también depende del tipo de modulación y aplicación.
Los principales efectos que sufre la señal al propagarse son:
• Atenuación
• Desvanecimiento
• Ruido Blanco aditivo
• Interferencia externa
• Ruido de fase
• Reflexión de señales
• Refracción
• Difracción
• Dispersión
Para que esta comunicación inalámbrica entre diversos dispositivos sea posible,
existen actualmente dos tipos de tecnologías: por infrarrojos y radiofrecuencia
La comunicación por radiofrecuencia tiene todas las cartas en la mano para ser
el estándar de las comunicaciones futuras. Su principal base reside en la
posibilidad de transmitir a mayor distancia, incluso a través de obstáculos entre
el emisor y el receptor. Sin embargo, las ondas electromagnéticas tampoco
están libres de inconvenientes, como el de las posibles interferencias con otros
aparatos que emitan en el mismo rango. Esta es una cuestión que ya está
siendo abordada por diversos organismos oficiales de todo el mundo con el
objetivo de ampliar el espacio electromagnético y ofrecer a los fabricantes de
este tipo de dispositivos otras posibilidades de frecuencia.
sea necesario, siempre que la interferencia entre estaciones con el mismo canal
se mantenga por debajo de unos niveles aceptables.
Los enlaces satelitales son comunicaciones por medio de microondas donde uno
de los extremos de la conexión se encuentra en el espacio y el otro en la tierra,
en forma de estación terrestre, que es la encargada de hacer la conexión entre
el satélite y el usuario final.
Un factor limitante para la comunicación microondas es que tiene que existir una
línea recta entre los dos puntos pero como la tierra es esférica esta línea se ve
limitada en tamaño entonces, colocando, ya sea el receptor o el transmisor, en el
espacio se cubre un área más grande de superficie.
Estaciones Terrenas
En muy poco tiempo la información que sea consultada por una computadora
personal se podrá hacer con un teléfono celular u algún otro dispositivo portátil.
La globalización de las comunicaciones inalámbricas ha permitido el desarrollo
de nuevos estándares y productos que muy pronto brindarán cambios en
nuestras actividades.
Los estándares inalámbricos tales como IEEE 802.11, IEEE 802.15, Bluetooth ,
HiperLAN/2, HomeRF en combinación con otras tecnologías no tan nuevas
como la telefonía celular aunado con nuevos protocolos como el WAP permitirán
la interconexión de las redes actuales e Internet a dispositivos móviles como
teléfonos celulares, PDAs , radiolocalizadores (pagers) de dos vías y otros
dispositivos portátiles.
Por último en esta categoría el acceso a Internet vía satélite ha jugado un papel
preponderante hoy en día. La ventaja más importante de las comunicaciones vía
satélite en el acceso a Internet es la gran cobertura que tiene, alta capacidad en
el orden de decenas de Mbps, provee accesos más directos a las dorsales
satelitales, las comunicaciones vía satélite pueden penetrar áreas remotas
donde otros medios de transmisión serían imposibles de llegar. En otras
palabras la comunicación vía satélite es capaz de dar acceso a Internet hasta en
una isla a miles de kilómetros de distancia. Quizá este sea el medio inalámbrico
más caro al principio debido a que hay que comprar infraestructura costosa
como las estaciones terrenas y pagar las altas mensualidades de ancho de
banda a un proveedor satelital. Existen opciones satelitales mucho más
económicas para usuarios residenciales o para pequeñas oficinas. Estos
sistemas que operan de manera híbrida y asimétrica utilizan pequeños platos
reflectores para la recepción de la información de Internet y empleando otro
medio alternativo para el regreso de la información, ya sea mediante una línea
privada de menos ancho de banda o mediante un módem casero. Este sistema
permite la recepción de Internet a velocidades de hasta 400 Kbps, un ejemplo de
este servicio es DirecPC. Existen también sistemas satelitales económicos pero
que operan de manera bidireccional para pequeños negocios o para
proveedores de Internet mediante pequeñas estaciones terrenas
transmisoras/receptoras.
Estándar WLL
WLL (Wireless Local Loop) es una importante tecnología que permite servicios
telefónicos que incrementan más el desarrollo de los diferentes países que los
sistemas cableados. Las capacidades de un sistema WLL está basado en la
aplicación TDMA (IS-54), el CDMA (IS -95A) y el ETSI GSM las cuales son
Estándar GSM
El estándar GSM define una red telefónica móvil terrestre (PLMN) completa, de
naturaleza digital y de servicios integrados, que comprende el acceso radio con
estructura celular, la transmisión, conmutación y señalización específicas para
soportar las funciones de movilidad y los mecanismos de seguridad para el
establecimiento de las llamadas y la protección de la información transmitida
durante éstas.
Los servicios básicos ofrecidos son los de telefonía y datos, que comprenden
transmisiones de textos, imágenes, fax, ficheros y mensajes.
El servicio básico de telefonía es similar al que prestan las redes clásicas fijas.
El usuario puede realizar y recibir llamadas hacia/desde cualquier red telefónica.
Este servicio tiene asociado el de mensajería vocal que permite el
almacenamiento de los mensajes para su posterior recuperación.
Los servicios de datos utilizan la red GSM principalmente como red de acceso.
Es posible entablar comunicación con diferentes redes destino a velocidades de
datos comprendidas entre 300 y 9600 bit/s, en modo síncrono o asíncrono. Los
servicios de datos en modo circuito pueden ser de tipo transparente o no
transparente (con detección de errores y retransmisión). En el modo
transparente la red usa el protocolo RLP (Radio Link Protocol), con un sistema
de control de errores que realiza la detección de errores y la retransmisión
consiguiente.
Estándar CDMA
Los sistemas IS-95 dividen el espectro en portadoras de 1.25 MHz. Unos de los
aspectos únicos de CDMA es que a pesar de que existe un número fijo de
llamadas telefónicas que pueden ser manipuladas por un proveedor de servicios
de telefonía (carrier), éste no es un número fijo. La capacidad del sistema va a
depender de muchos factores.
Hoy en día existen muchas variantes, pero el CDMA original es conocido como
cdmaOne bajo una marca registrada de Qualcomm. A CDMA se le caracteriza
por su alta capacidad y celdas de radio pequeño, que emplea espectro
extendido y un esquema de codificación especial y lo mejor de todo es muy
eficiente en potencia.
Debido a que Bluetooth funciona con RF no está sujeto a tales limitaciones. Las
distancia de conexión en Bluetooth puede ser de hasta 10 metros o más
dependiendo del incremento de la potencia del transmisor, pero los dispositivos
no necesitan estar en línea de vista ya que las señales de RF pueden atravesar
paredes y otros objetos no metálicos sin ningún problema.
Bluetooth opera en la banda 2.4 GHz bajo la tecnología de radio conocida como
espectro disperso. La banda de operación está dividida en canales de 1 MHz, a
1 megasímbolo por segundo puede obtenerse al ancho de banda máximo por
canal. Con el esquema de modulación empleado, GFSK (Gaussian Frequency
Shift Keying), esto equivale a 1 Mbps. Utilizando GFSK, un 1 binario representa
una desviación positiva de la portadora nominal de la frecuencia, mientras que
un 0 representa una desviación negativa. Después de cada paquete, ambos
dispositivos re-sintonizan su radio transmisor a una frecuencia diferente,
saltando de un canal a otro canal de radio; esta técnica se le conoce como
De esta manera, los dispositivos Bluetooth utilizan toda la banda de 2.4 GHz y
si una transmisión se interfiere sobre un canal, una retransmisión siempre
ocurrirá sobre un canal diferente con la esperanza de que este canal esté libre.
Cada ranura de tiempo tiene una duración de 625 microsegundos y
generalmente los dispositivos saltan una vez por paquete, o sea, saltan cada
ranura, cada 3 ranuras o cada 5 ranuras. Como Bluetooth fue diseñado para
aplicaciones móviles de poca potencia, la potencia del radio transmisor debe ser
minimizada. Tres diferentes clases de niveles de potencias están definidas, las
cuales proveen rangos de operación de aproximadamente 10, 20 y 100 metros:
El más bajo nivel de potencia cubre 10 metros, el más alto nivel logra cubrir
distancias de hasta 100 metros.
La especificación Bluetooth
Como Bluetooth opera en una banda de uso libre conocida como ISM
(Industrial, Scientific, and Medical) donde otros dispositivos de uso común la
utilizan como es el caso de puertas de cocheras, teléfonos inalámbricos, hornos
de microondas, sólo por nombrar algunos. Para que los dispositivos Bluetooth
puedan coexistir y operar confiablemente con los otros dispositivos, cada
picocelda es sincronizada a una frecuencia específica del patrón de salto por
frecuencia. Este patrón, que salta a 1,600 frecuencias diferentes por segundo,
es único para una picocelda en particular. Cada "salto" de frecuencia es una
ranura de tiempo durante la cual los paquetes de datos son transferidos. Un
paquete puede abarcar hasta 5 ranuras de tiempo, en la cual la frecuencia
permanece constante durante la duración de esa transferencia.
Varios protocolos interactúan con la capa de enlace L2CAP tales como SDP y
RFCOMM. El protocolo SDP (Service Discovery Protocol) provee un medio
para determinar que servicios Bluetooth están disponibles en un dispositivo
particular.
Un dispositivo Bluetooth puede actuar como un cliente SDP solicitando
servicios o como un servidor SDP proveyendo servicios, o ambos. Un simple
dispositivo Bluetooth tendrá no más de un servidor SDP, pero puede actuar
como un cliente para más de un dispositivo remoto. El protocolo SDP provee
acceso sólo a información acerca de servicios, la utilización de esos servicios
Satélites Orbitales
Satélites Geoestacionarios
Modelo de subida
Transponder
Modelo de bajada
Enlaces cruzados
La distancia cubierta por enlaces microondas puede ser incrementada por el uso
de repetidoras, las cuales amplifican y redireccionan la señal, es importante
destacar que los obstáculos de la señal pueden ser salvados a través de
reflectores pasivos. Las siguientes figuras muestran como trabaja un repetidor y
como se ven los reflectores pasivos.
48 Canales VF
Terminal C
Repetidor
96 Canales VF
48 Canales VF
Estaciones Terrenas
Tierra
Otro punto que cabe destacar es que existen satélites que se encargan de
regenerar la señal recibida antes de retransmitirla, pero estos solo pueden ser
utili zados para señales digitales, mientras que los satélites que no lo hacen
pueden trabajar con ambos tipos de señales (Análogas y Digitales).
• Amplificación de la señal
• Aislamiento de canales adyacentes
• Traslación de frecuencias
Al igual que las redes tradicionales alámbricas vamos a clasificar a las redes
inalámbricas en:
5.3.2.1 IP Móvil
Una máquina en la red tiene siempre tiene una dirección IP, la cuál se conforma
con una parte fijada por la subred en que se encuentra (prefijo de red) y otra
parte pertenece directamente a la dirección de la máquina. Esta dirección IP le
sirve al router para que pueda hacer llegar los paquetes o datagramas que un
usuario en la red le envía a otro, ya sea dentro de la misma red o en una red
diferente, o incluso en subredes diferentes.
Si un máquina cambia de red, tiene que cambiar su dirección IP, esto hará que
las conexiones (TCP) que tuviera abiertas se terminan., además todos los
paquetes que eran enviados hacia ella, no podrán ser entregados porque se
encuentra en una red diferente y como ya lo mencionamos su dirección IP habrá
cambiado.
El IP móvil es una tecnología que permite que un nodo de red ("nodo móvil")
emigre de su "casa" red a otras redes, o dentro del mismo dominio de la
administración, o a otros dominios administrativos. El IP móvil puede seguir una
computadora principal móvil sin necesitar cambiar la dirección IP del móvil a lo
largo de sus pasos por diferentes redes.
Sin el IP móvil, uno de los dos mecanismos siguientes se debe emplear para
que un nodo cambie su punta de la conexión sin perder su capacidad de
comunicarse:
El IP móvil fue ideado para resolver las metas siguientes para los nodos móviles
que no se mueven con más frecuencia que una vez por segundo. Permite a los
nodos moverse a partir de una subred a otra. Es conveniente para la movilidad a
través de medios heterogéneos como para la movilidad a través de medios
homogéneos.
Fundamentos de IP Móvil
En la red local, un Agente Local (Home Agent) sabe qué Dirección de Auxilio
tiene en cada momento el terminal móvil:
Como podemos ver el Agente Local funciona como un intermediario entre las
máquinas que se quieren comunicar con la terminal móvil, ya que recibe los
mensajes que va n hacia a ella y después los reenvía, por lo tanto, este Agente
Problemas de IP Móvil
WLAN son las siglas en inglés de Wireless Local Area Network. Es un sistema
de comunicación de datos flexible muy utilizado como alternativa a la LAN
cableada o como una extensión de ésta. Las WLAN han adquirido importancia
en muchos campos incluido el de la medicina.
Como todos los estándares 802 para redes locales del IEEE, en el caso de las
WLAN, también se centran en los dos niveles inferiores del modelo OSI, el físico
y el de enlace, por lo que es posible correr por encima cualquier protocolo
(TCP/IP o cualquier otro) o aplicación, soportando los sistemas operativos de red
habituales, lo que supone una gran ventaja para los usuarios que pueden seguir
utilizando sus aplicaciones habituales, con independencia del medio empleado,
sea por red de cable o por radio. La especificación IEEE 802.11 define redes
locales inalámbricas que emplean ondas de radio en la banda de 2.4 GHz y 5
GHz conocido como espectro esparcido. Las velocidades típicas de esta
tecnología son 11 Mbps en la especificación IEEE 802.11b y está en desarrollo
la especificación IEEE 802.11a en la banda de 5 GHz que alcanzará velocidades
de hasta 54 Mbps.
Las redes locales inalámbricas se han vuelto muy populares hoy en día, éstas
pueden proveer acceso a Internet por ejemplo a estudiantes alrededor de un
campus universitario utilizando una computadora portátil provista con una tarjeta
con acceso inalámbrico.
Respecto a la red tradicional la red sin cable ofrece las siguientes ventajas:
Configuraciones de la WLAN
Los puntos de acceso tienen un rango finito, del orden de 150m en lugares
cerrados y 300m en zonas abiertas. En zonas grandes como por ejemplo un
campus universitario o un edificio es probablemente necesario más de un punto
de acceso. La meta es cubrir el área con células que solapen sus áreas de modo
que los clientes puedan moverse sin cortes entre un grupo de puntos de acceso.
Esto es llamado "roaming".
WWAN (Wireless Wide Area Networks) son redes extensas sin cables.
Ejemplos de este tipo de redes son las redes de telefonía móvil: GSM, GPRS,
TDMA, etc.
El alcance de una WWAN puede llegar hasta 30 km, lo que ofrece a los usuarios
un modo de seguir conectados mientras se desplazan o están alejados de otra
infraestructura de red.
Las redes de área amplia inalámbricas transmiten los datos mediante señales de
telefonía móvil, a través de un proveedor de servicios de telefonía móvil, con
velocidades de conexión similares a las de acceso telefónico de 56K. Las
velocidades de descarga están limitadas a 53 Kbps. Las velocidades de carga
son inferiores (unos 30 Kbps). Las velocidades pueden variar según el estado de
la línea y el fabricante del módem. Es necesario disponer de una línea telefónica
analógica y del servicio. (El alcance y la velocidad varían según el entorno y
otros factores.)
Es por eso que WAP utiliza un lenguaje conocido como WML (Wireless Markup
Language) que permite la conexión entre las redes y los dispositivos portátiles.
Otras tecnologías WAN/MAN que permiten el acceso a Internet a altas
velocidades son MMDS, LMDS, WLL, enlaces de microondas terrestres, vía
láser infrarrojo y comunicaciones vía satélite.
EJERCICIO
En el siguiente ejemplo, vamos a crear una aplicación Windows para una Pocket
PC y una Aplicación Web, la cuál vamos a acceder desde la Pocket PC.
10. Dentro de las propiedades del label1, ajustamos Text a vacío, sin
texto.
19. Corra la Aplicación. De clic en alguno de los botones. Vea las salidas
que genera el programa.
En el siguiente ejemplo, vamos a crear una aplicación Web ASP.NET para que
sea accedido desde una Pocket PC. La aplicación se creará primero en el IIS de
una máquina, para posteriormente acceder a dicha WebForm por medio de la
Pocket PC.
10. Seleccione Generar -> Generar Solución. El programa debe generarse sin
errores.
12. Se abre una nueva ventana del Browser con la dirección donde se genero
su Aplicación Web ASP.NET
Puntos de
Arriba del Debajo del
Atributos En el Estándar Atributo
Estándar Estándar
Obtenidos
(10-9 ) (8.5-7) (6.5-0)
La información
La información La información
revisada
revisada permitió revisada no
permitió a los
Aplicación de a los estudiantes permitió a los
la estudiantes
comprender con estudiantes
comprender
Información claridad los comprender
solamente los
ejercicios y los ejercicios y
ejercicios y
programas. programas.
programas.
(10-9 ) (8.5-7) (6.5-0)
Los estudiantes
han demostrado
Los
el significado del
Los estudiantes estudiantes no
material
han demostrado han hecho
elaborando
el significado del contacto con
correctamente,
Conexiones material el material,
mientras
Especialistas incorporándolo simplemente
extienden y
correctamente sin incorporar
explican la
en el estudio del la información
información, en su estudio
tema.
incorporándola en
del tema.
el estudio del
tema.
Total de Puntos Obtenidos