Sistemas Distribuidos

Enero - Mayo 2017

Practica de
Programacin 1
Reporte de protocolo
UDP

Jatar Atala Moreno Lacalle

UDPClient
package udpclient;

import java.net.*;
import java.io.*;

/**
*
* @author jatar_000
*/
public class UDPClient {

public static void main(String args[]) {

// args = mensaje y nombre del servidor
DatagramSocket aSocket = null;// Se crea una conexion de tipo DatagramPacket para
inicar la comunicacion
try {
aSocket = new DatagramSocket();//Se inicia la conexion
byte[] m = args[0].getBytes();//una veriable m para el tamao en bytes del mensaje
InetAddress aHost = InetAddress.getByName(args[1]);//Recibe la direccion en aHost
int serverPort = 6789;//el puerto de salida es 6789
DatagramPacket request = new DatagramPacket(m, args[0].length(), aHost,
serverPort);
//empaqueta los datos anteriores en un datagrama
aSocket.send(request);//envia al aSocket la peticion
 byte[] buffer = new byte[1000];//crea un buffer para poner ahi el mensaje
DatagramPacket reply = new DatagramPacket(buffer, buffer.length);//datagrama de
respuesta
aSocket.receive(reply);//recibe la respuesta
System.out.println("Reply: " + new String(reply.getData()));//imprime la respuesta
} catch (SocketException e) {
System.out.println("Socket: " + e.getMessage());//excepcion de socket
} catch (IOException e) {
System.out.println("IOS: " + e.getMessage());
}//excepcion de entrada/salida
}
}

UDPServer
package udpserver;

import java.net.*;
import java.io.*;

/**
*
* @author jatar_000
*/
public class UDPServer {

public static void main(String args[]) {

DatagramSocket aSocket = null;// Se crea una conexion de tipo DatagramPacket para
inicar la comunicacion
try {
aSocket = new DatagramSocket(6789);//recibe el mensaje por el puerto 6789
byte[] buffer = new byte[1000];//buffer para recepcion y respuesta
while (true) {//eschucha mientras llegan peticiones
//variable de peticion de tipo DatagramPacket
DatagramPacket request = new DatagramPacket(buffer, buffer.length);
aSocket.receive(request);//recibe mensaje
DatagramPacket reply = new DatagramPacket(request.getData(),//crea la la
respuesta del resvidor
request.getLength(), request.getAddress(), request.getPort());//obtiene datos
de la peticion: tamao, direccion, puerto
aSocket.send(reply);//envia respuesta
}
} catch (SocketException e) {
 System.out.println("Socket: " + e.getMessage());
} catch (IOException e) {
System.out.println("IO: " + e.getMessage());
}
}
}

UDPDiscardClient

import java.net.*;

import java.io.*;

public class UDPDiscardServer {

public final static int port = 9;//declara variable int DiscartPort

public static void main(String[] args) {

String hostname;//variable para el nombre del host

if (args.length > 0) {

hostname = args[0];//pasa el nombre del host a hostname

} else {

hostname = "localhost";//Si no se recibe el nombre del hosto, le pondra localhost

try {

String theLine;//Variable linea

DatagramPacket theOutput;//Datagrama de salida

InetAddress server = InetAddress.getByName(hostname);//direccion del servidor

BufferedReader userInput = new BufferedReader(new

InputStreamReader(System.in));//toma lo que se ingresa por consola y lo coloca en el buffer

DatagramSocket theSocket = new DatagramSocket();//Datagrama de conexion

 while (true) {//siempre escucha

theLine = userInput.readLine();//obtiene el valor escrito en consola

if (theLine.equals(".")) {

break;

termina el mensaje al recibir un .

byte[] data = new byte[theLine.length()];//obtiene el tamao del msj

data = theLine.getBytes();//;envia el msj

theOutput = new DatagramPacket(data, data.length, server, port);

theSocket.send(theOutput);//Envia el datagrama

} // end while

} // end try

catch (UnknownHostException e) {

System.err.println(e);

} catch (SocketException se) {

System.err.println(se);

} catch (IOException e) {

System.err.println(e);

} // end main

UDPDiscradServer

import java.net.*;

import java.io.*;
public class UDPDiscardServer {

public final static int discardPort = 9;//declara variable int DiscartPort

static byte[] buffer = new byte[65507];//crea un buffer

public static void main(String[] args) {

int port;//un entero llamado puerto

try {

port = Integer.parseInt(args[0]);//parsea el puerto a un entero

} catch (Exception e) {

port = discardPort;//se le asigna al puerto el DiscartPort

try {

DatagramSocket ds = new DatagramSocket(port);//nuevo Datagrama ds

while (true) {//escucha todo el tiempo

try {

//Se envia al DatagramPacket lo que esta en el buffer

DatagramPacket dp = new DatagramPacket(buffer, buffer.length);

ds.receive(dp);//pone el mensaje en el Datagrama ds

String s = new String(dp.getData(), 0, dp.getLength());//Recupera el msj que

mando con el tamao con la variable s

System.out.println(dp.getAddress() + " at port " + dp.getPort() + " says " +

s);//Imprime el msj que envio con la direccion y puerto

} catch (IOException e) {

System.err.println(e);

} // end while

} // end try

catch (SocketException se) {

 System.err.println(se);

} // end catch

} // end main

Conversor C a F
Cliente

package updclient;

/**

* @author jatar_000

*/

import java.net.*;

import java.io.*;

public class UPDClient_Conversor {

/**

* @param args the command line arguments

* @throws java.lang.Exception

*/

public static void main(String args[]) throws Exception {

byte[] sendData;

byte[] receiveData;

BufferedReader inFromKeyboard = new BufferedReader(new

InputStreamReader(System.in));
 try {

DatagramSocket clientSocket = new DatagramSocket(8888);

InetAddress IPAddress = InetAddress.getByName("127.0.0.1");

while (true) {

/**

* *******************************

* create a new buffer each time

*/

sendData = new byte[1024];

receiveData = new byte[1024];

/**

* ******************************

*/

System.out.println("Introducir TEMP y el valor de la temperatura en Celsius[-

200,200]: ");

String sentence = inFromKeyboard.readLine();

//sending TEMP command

if (sentence.startsWith("TEMP")) {

sendData = sentence.getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData,

sendData.length, IPAddress, 9999);

clientSocket.send(sendPacket);

DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);

System.out.println(
 "Temperatura enviada al servidor : " + sentence + "C" + "\n Esperando al
servidor....");

clientSocket.receive(receivePacket);

String fromServer = new String(receivePacket.getData());

System.out.println("Respuesta del servidor : " + fromServer + "F");

} catch (Exception e) {

e.printStackTrace();

Servidor

package udpserver;

/**
*
* @author jatar_000
*/
import java.net.*;
import java.io.*;

class UDPServer_Conversor{

public static void main(String arg[]) throws Exception {

DatagramSocket serversocket = new DatagramSocket(9999);
UDPServer udpserver = new UDPServer();
byte[] receivedBuffer; // = new byte[1024];
byte[] sentBuffer; //= new byte[1024];
while (true) {
receivedBuffer = new byte[1024];
sentBuffer = new byte[1024];
 DatagramPacket receivedpacket = new DatagramPacket(receivedBuffer,
receivedBuffer.length);
System.out.println("Servidor en linea.....");

serversocket.receive(receivedpacket);
String fromClient = new String(receivedpacket.getData());
// Convertir temperatura en Farenheith
if (fromClient != null && fromClient.startsWith("TEMP")) {

InetAddress clientIP = receivedpacket.getAddress();

System.out.println("Mensaje recibido del cliente : " + fromClient + " Direccion
IP = "
+ clientIP.getHostAddress() + ", Host= " + clientIP.getHostName());
float temp = Float.parseFloat(fromClient.substring(fromClient.indexOf(' ') + 1));
if (temp <= 200 && temp >= -200) {
float tempInFaren = (float) (temp * 1.8 + 32.0);
//float toClient = tempInFaren ;
String convertIntoFarenheit = String.valueOf(tempInFaren);

sentBuffer = convertIntoFarenheit.getBytes();
DatagramPacket sendpacket = new DatagramPacket(sentBuffer,
sentBuffer.length, clientIP, 8888);
serversocket.send(sendpacket);
System.out.println(" Respuesta enviada al cliente " +
clientIP.getHostAddress());
} else {
String convertIntoFarenheit = "Error,introdusca un valor entre [-200,200]";
sentBuffer = convertIntoFarenheit.getBytes();
DatagramPacket sendpacket = new DatagramPacket(sentBuffer,
sentBuffer.length, clientIP, 8888);
serversocket.send(sendpacket);
System.out.println(" Respuesta enviada al cliente " +
clientIP.getHostAddress());
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException ie) {
}
}
}
}
 Diagrama de secuencia
o Datagramas: Son los mensajes que se envan.
o Cliente: Enva y recibe mensajes (datagramas).
o Sockets: Son las conexiones de entrada y salida entre el Cliente y el servidor.
o Servidor: Recibe y enva una respuesta al cliente.

Manda y recibe mensajes del

Cliente servidor dentro de un datagrama

Cliente y servidor se conectan

Sockets entre si con sus respectivas
conecciones.

Recibe la consulta del servidor y

Servidor envia la respuesta por medio de
datagramas