--- /dev/null
+\documentclass{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[spanish]{babel}
+\usepackage{times}
+
+\usepackage{color}
+\definecolor{gray97}{gray}{.97}
+\definecolor{gray75}{gray}{.75}
+\definecolor{gray45}{gray}{.45}
+
+\usepackage{listings}
+\lstset{ frame=Ltb,
+ framerule=0pt,
+ aboveskip=0.5cm,
+ framextopmargin=3pt,
+ framexbottommargin=3pt,
+ framexleftmargin=0.4cm,
+ framesep=0pt,
+ rulesep=.4pt,
+ backgroundcolor=\color{gray97},
+ rulesepcolor=\color{black},
+ %
+ stringstyle=\ttfamily,
+ showstringspaces = false,
+ basicstyle=\small\ttfamily,
+ commentstyle=\color{gray45},
+ keywordstyle=\bfseries,
+ %
+ numbers=left,
+ numbersep=15pt,
+ numberstyle=\tiny,
+ numberfirstline = false,
+ breaklines=true,
+ }
+
+% minimizar fragmentado de listados
+\lstnewenvironment{listing}[1][]
+ {\lstset{#1}\pagebreak[0]}{\pagebreak[0]}
+
+\lstdefinestyle{consola}
+ {basicstyle=\scriptsize\bf\ttfamily,
+ backgroundcolor=\color{gray75},
+ }
+
+\lstdefinestyle{java}
+ {language=java, }
+
+\lstdefinestyle{idl}
+ {language=IDL, }
+
+\lstdefinestyle{Python}
+ {language=Python, }
+
+\title{Práctica PCD 07/08 - Subastas}
+\author{Daniel García Moreno <dani@danigm.net>}
+\date{\today}
+
+\begin{document}
+\maketitle
+
+\tableofcontents
+
+\section{Cómo compilar y ejecutar}
+
+\subsection{Compilar}
+ Para compilar hay que ejecutar:
+ \texttt{javac src/subastas/*.java -d bin/}
+ desde el directorio PCD. Los .class se guardarán en el directorio
+ bin.
+
+\subsection{Ejecutar}
+
+ El cliente y servidor se comunican a través de un fichero .ior,
+ así que el servidor tiene que tener permiso de escritura en el directorio
+ desde el cual se ejecute y el cliente tiene que ejecutarse desde
+ el mismo directorio despues de haber ejecutado el servidor.
+
+ \begin{itemize}
+ \item \textbf{Servidor:}
+ \texttt{java -classpath PCD/bin subastas.Servidor}
+ \item \textbf{Cliente:}
+ \texttt{java -classpath PCD/bin subastas.Cliente}
+ \end{itemize}
+
+ Para conocer los comandos disponibles en el cliente basta con
+ escribir el comando 'help' que mostrará una lista con todos los
+ posibles comandos.
+
+ Hay que tener en cuenta que para poder hacer alguna operación con
+ alguna de las subastas creadas hay que hacer una busqueda para que
+ se inicialice el vector de subastas, y el id será el indice en
+ esta busqueda.
+
+\section{Explicación del diseño}
+
+\subsection{Interfaces IDL}
+ Las tres interfaces que hay que implementar se han implementado
+ dentro del modulo subastas.
+
+ \subsubsection{clienteSubastas}
+
+ La interfaz clienteSubastas está implementada según la
+ especificación del trabajo y además contiene una operación
+ nuevoValor que sirve para resolver el primer problema especificado
+ en el documento.
+
+ \subsubsection{coordinadorSubasta}
+
+ Para la interfaz gestorSubasta se ha declarado un tipo de dato
+ sequence para la lista de clientes.
+
+ En esta interfaz se definen los atributos y las operaciones
+ especificadas en el documento. Además se define la operación
+ cerrarSubasta que será llamado para cerrar una subasta y así
+ evitar el segundo problema.
+
+ \subsubsection{gestorSubastas}
+
+ Para la interfaz gestorSubasta se ha definido un tipo sequence
+ para la lista de subastas que hay que devolver en la operación
+ localizarSubasta.
+
+ Por lo demás se ha implementado según lo especificado en el
+ documento.
+
+\subsection{Sirvientes}
+
+ Se han implementado los sirvientes:
+
+ \subsubsection{clienteSubastasImpl}
+ Este sirviente implementa la interfaz clienteSubastas por
+ herencia. Se han implementado las operaciones según la
+ especificación. Cuando se actualiza el valor de una suabasta el
+ cliente será informado por el coordinador subasta e imprimirá el
+ nuevo valor.
+
+ \subsubsection{coordinadorSubastaImpl}
+ Al igual que el sirviente anterior este está implementado por
+ herencia. Se han definido las operaciones según lo especificado en
+ el documento.
+
+ Se han definido los métodos \texttt{abrirSubasta},
+ \texttt{ganador}, \texttt{pujar}, \texttt{ultimaPuja} y
+ \texttt{cerrarSubasta} como synchronized puesto que serán llamados
+ desde diferentes clientes. Para la sincronización entre clientes
+ se utilizan los métodos proporcionados por java y vistos en clase,
+ wait y notifyAll. Cuando se cambia el estado se ejecuta notifyAll.
+
+ Las esperas de los clientes se realizan mediante wait y el
+ atributo estado.
+
+ \subsubsection{gestorSubastasImpl}
+ Como los dos sirvientes anteriores este también se ha implementado
+ por herencia.
+
+ Este sirviente es un objeto fábrica. Crea coordinadores de
+ subastas.
+
+ Para evitar el segundo problema especificado en el documento se ha
+ utilizado la clase SubastaKiller que implementa la interfaz
+ Runnable para ser lanzado en un hilo. Este hilo duerme durante el
+ tiempo especificado y después cierra la subasta especificada
+ llamando al método cerrarSubasta del coordinadorSubasta.
+
+ El resto de operaciones está implementado según la especificación
+ del documento.
+
+\subsection{SubastaKiller}
+ Para solventar el problema de que una subasta no acabe nunca por
+ culpa de un cliente se ha implementado esta clase que implementa
+ la interfaz Runnable. Este hilo duerme durante un tiempo
+ especificado y después cierra la subasta.
+
+\subsection{Servidor}
+ El servidor crea un gestorSubastasImpl y crea un fichero
+ \texttt{server.ior} donde escribe el ior correspondiente a este
+ objeto. Y se lanza el servidor.
+
+\subsection{Cliente unificado}
+ Esta es la parte con más código del trabajo aunque no por ello la
+ más compleja.
+
+ Se han definido los suiguientes comandos:
+
+ \begin{verbatim}
+ /**
+ * COMANDOS DISPONIBLES
+ *
+ * GESTOR SUBASTAS
+ * ---------------
+ * salir -> sale del bucle
+ * crear valor tiempo desc -> crea una subasta
+ * buscar desc -> busca una subasta y muestra todas las coincidencias
+ * borrar id -> borra una subasta si esta cerrada
+ *
+ * COORDINADOR SUBASTA
+ * -------------------
+ * abrir id -> abre la subasta por id
+ * estado id -> devuelve el estado de una subasta
+ * valor id -> devuelve el valor actual de una puja
+ * ganador_prov id -> dice el identificador del cliente que va ganando la puja
+ * ganador id -> muestra el ganador, si la puja no esta cerrada aun, bloquea al cliente
+ * clientes id -> muestra todos los identificadores de los clientes de la subasta
+ * inscribir id cliente_id -> inscribe un cliente en una subasta
+ * pujar id cliente_id valor
+ * ultima id cliente_id
+ *
+ * CLIENTE SUBASTAS
+ * ----------------
+ * crearcliente identificacion
+ * cldisp -> muestra los clientes disponibles
+ */
+ \end{verbatim}
+
+ Cuando se ejecuta un cliente muestra una línea de comandos que
+ permite llamar a cualquiera de estos comandos. No se han capturado
+ los errores por lo que si se llama a alguno con una sintaxis
+ inadecuada el programa dará errores.
+
+ Este cliente unificado permite tanto crear y gestionar subastas
+ como crear clientes y trabajar con más de un cliente desde un
+ mismo cliente unificado.
+
+\section{Código fuente}
+
+\subsection{Definción de interfaces en IDL}
+\begin{lstlisting}[style=java]
+
+module subastas{
+
+
+ interface clienteSubastas{
+ readonly attribute string identificacion;
+ void finSubasta();
+ void nuevoValor(in float valor);
+ };
+
+ typedef sequence<clienteSubastas> lista_clientes;
+ interface coordinadorSubasta{
+ /**
+ * coordinadorSubasta: interfaz de objetos que gestionan el
+ * desarrollo de la subasta de cada bien subastado por la empresa.
+
+ * La subasta pasara por tres estados:
+ * Inscripcion
+ * Abierta
+ * Cerrada
+ *
+ */
+
+ readonly attribute clienteSubastas ganador_provisional;
+ readonly attribute lista_clientes clientes;
+
+ readonly attribute float valor;
+ readonly attribute string descripcion;
+ // Inscripcion -> Abierta -> Cerrada
+ readonly attribute string estado;
+
+ void inscribirCliente(in clienteSubastas cl);
+ void abrirSubasta();
+ boolean pujar(in float cantidad, in clienteSubastas cl);
+ void ultimaPuja(in clienteSubastas cl);
+ clienteSubastas ganador();
+ void cerrarSubasta();
+ };
+
+ typedef sequence<coordinadorSubasta> lista_subastas;
+ interface gestorSubastas{
+ coordinadorSubasta crearSubasta(in float valor, in string desc, in long tiempo);
+ void destruirSubasta(in coordinadorSubasta cs);
+ lista_subastas localizarSubasta(in string palabra);
+ };
+
+};
+
+\end{lstlisting}
+
+\subsection{clienteSubastasImpl.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+
+/**
+ * @author danigm
+ *
+ */
+public class clienteSubastasImpl extends clienteSubastasPOA {
+ private String identificacion;
+ private boolean fin=false;
+ private float valor_subasta=0;
+ public clienteSubastasImpl(String id) {
+ super();
+ identificacion = id;
+ }
+
+ public void finSubasta() {
+ fin = true;
+ }
+
+ public String identificacion() {
+ return identificacion;
+ }
+
+ public void nuevoValor(float valor) {
+ valor_subasta = valor;
+ System.out.println("NUEVO VALOR " + valor);
+ }
+
+}
+\end{lstlisting}
+
+
+\subsection{coordinadorSubastaImpl.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+import java.util.Vector;
+
+/**
+ * @author danigm
+ *
+ */
+public class coordinadorSubastaImpl extends coordinadorSubastaPOA {
+ private clienteSubastas ganador_provisional;
+ private Vector<clienteSubastas> clientes;
+ private float valor;
+ private String descripcion;
+ // Inscripcion -> Abierta -> Cerrada
+ private String estado;
+
+ public coordinadorSubastaImpl(float v_inicial, String desc) {
+ super();
+ estado = "Inscripcion";
+ ganador_provisional=null;
+ clientes = new Vector<clienteSubastas>();
+ valor = v_inicial;
+ descripcion = desc;
+ }
+
+ synchronized public void abrirSubasta() {
+ if(estado.equals("Inscripcion")){
+ estado = "Abierta";
+ notifyAll();
+ }
+ }
+
+ public clienteSubastas[] clientes() {
+ clienteSubastas[] cs = new clienteSubastas[clientes.size()];
+ for (int i=0; i<clientes.size(); i++)
+ cs[i] = clientes.get(i);
+ return cs;
+ }
+
+ public String descripcion() {
+ return descripcion;
+ }
+
+ public String estado() {
+ return estado;
+ }
+
+ public synchronized clienteSubastas ganador() {
+ //Si la puja esta cerrada devuelve ganador
+ //sino se bloquea hasta que se cierre
+ try {
+ while(!estado.equals("Cerrada"))
+ wait();
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return ganador_provisional;
+ }
+
+ public clienteSubastas ganador_provisional() {
+ return ganador_provisional;
+ }
+
+ public void inscribirCliente(clienteSubastas cl) {
+ //estaria bien lanzar una excepcion
+ if(estado.equals("Inscripcion"))
+ clientes.add(cl);
+
+ }
+
+ public synchronized boolean pujar(float cantidad, clienteSubastas cl) {
+ String id = cl.identificacion();
+ try {
+ while(estado.equals("Inscripcion"))
+ wait();
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ if(estado.equals("Cerrada"))
+ return false;
+ else{
+ if (clientes.contains(cl)){
+ if (cantidad > valor){
+ valor = cantidad;
+ ganador_provisional = cl;
+ for (int i=0; i<clientes.size(); i++)
+ clientes.get(i).nuevoValor(valor);
+ return true;
+ }
+ else
+ return false;
+ }
+ else{
+ //quizas mejor una excepcion
+ return false;
+ }
+ }
+
+ }
+
+ synchronized public void ultimaPuja(clienteSubastas cl) {
+ if (clientes.contains(cl)){
+ clientes.remove(cl);
+ }
+ if (clientes.size() == 0) {
+ estado = "Cerrada";
+ notifyAll();
+ }
+ }
+
+ public float valor() {
+ return valor;
+ }
+
+ synchronized public void cerrarSubasta() {
+ estado = "Cerrada";
+ notifyAll();
+ }
+
+}
+\end{lstlisting}
+
+
+\subsection{gestorSubastasImpl.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+
+import java.util.Vector;
+
+import org.omg.CORBA.*;
+import org.omg.CORBA.ORBPackage.InvalidName;
+import org.omg.PortableServer.POA;
+import org.omg.PortableServer.POAHelper;
+import org.omg.PortableServer.POAManagerPackage.AdapterInactive;
+import org.omg.PortableServer.POAPackage.ServantNotActive;
+import org.omg.PortableServer.POAPackage.WrongPolicy;
+
+
+
+/**
+ * @author danigm
+ *
+ */
+public class gestorSubastasImpl extends gestorSubastasPOA {
+
+ private Vector<coordinadorSubasta> subastas;
+
+ private POA poa;
+ public gestorSubastasImpl(POA arg_poa) {
+ super();
+ subastas = new Vector<coordinadorSubasta>();
+ poa = arg_poa;
+ }
+
+ public coordinadorSubasta crearSubasta(float valor, String desc, int tiempo) {
+ coordinadorSubasta c = null;
+ coordinadorSubastaImpl coord = new coordinadorSubastaImpl(valor, desc);
+ org.omg.CORBA.Object obj;
+ try {
+ obj = poa.servant_to_reference(coord);
+ c = coordinadorSubastaHelper.narrow(obj);
+ subastas.add(c);
+ } catch (ServantNotActive e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (WrongPolicy e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ SubastaKiller sk = new SubastaKiller(c, tiempo);
+
+ return c;
+ }
+
+ public void destruirSubasta(coordinadorSubasta cs) {
+ if (cs.estado().equals("Cerrada")){
+ subastas.remove(cs);
+ }
+ }
+
+ public coordinadorSubasta[] localizarSubasta(String palabra) {
+ coordinadorSubasta[] encontradas = new coordinadorSubasta[subastas.size()];
+ int j=0;
+ for(int i=0; i<subastas.size(); i++){
+ if (subastas.get(i).descripcion().contains(palabra)){
+ encontradas[j] = subastas.get(i);
+ j++;
+ }
+ }
+ coordinadorSubasta[] encontradas2 = new coordinadorSubasta[j];
+ for(int i=0; i<j; i++){
+ encontradas2[i] = encontradas[i];
+ }
+
+ return encontradas2;
+ }
+
+}
+\end{lstlisting}
+
+\subsection{SubastaKiller.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+
+public class SubastaKiller implements Runnable{
+
+ private Thread hilo;
+ private long time;
+ private coordinadorSubasta cs;
+
+ public SubastaKiller(coordinadorSubasta cs, int time){
+ hilo = new Thread(this);
+ this.time = time*1000;
+ this.cs = cs;
+ hilo.start();
+ }
+
+ public void run() {
+ try {
+ hilo.sleep(time);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ cs.cerrarSubasta();
+
+ }
+
+
+}
+\end{lstlisting}
+
+\subsection{Servidor.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
+
+import org.omg.CORBA.*;
+import org.omg.CORBA.ORBPackage.InvalidName;
+import org.omg.PortableServer.*;
+import org.omg.PortableServer.POAManagerPackage.AdapterInactive;
+import org.omg.PortableServer.POAPackage.ServantNotActive;
+import org.omg.PortableServer.POAPackage.WrongPolicy;
+
+public class Servidor {
+
+ /**
+ * @param args
+ * @throws InvalidName
+ * @throws AdapterInactive
+ * @throws WrongPolicy
+ * @throws ServantNotActive
+ * @throws FileNotFoundException
+ */
+ public static void main(String[] args) throws InvalidName, AdapterInactive, ServantNotActive, WrongPolicy, FileNotFoundException {
+ //inicializacion del orb
+ ORB orb = ORB.init(args, null);
+
+ //creacion del poa raiz
+ POA poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
+
+ //crear y activar sirvientes
+ poa.the_POAManager().activate();
+ gestorSubastasImpl sirviente = new gestorSubastasImpl(poa);
+ org.omg.CORBA.Object obj = poa.servant_to_reference(sirviente);
+
+ String ior = orb.object_to_string(obj);
+ PrintWriter ps = new PrintWriter(new FileOutputStream(new File("server.ior")));
+ ps.println(ior);
+ ps.close();
+
+ orb.run();
+ }
+
+}
+\end{lstlisting}
+
+\subsection{Cliente.java}
+
+\begin{lstlisting}[style=java]
+
+package subastas;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.LineNumberReader;
+
+import org.omg.CORBA.*;
+import org.omg.PortableServer.POA;
+import org.omg.PortableServer.POAHelper;
+import org.omg.PortableServer.POAPackage.ServantNotActive;
+import org.omg.PortableServer.POAPackage.WrongPolicy;
+
+public class Cliente {
+
+ /**
+ * @param args
+ * @throws IOException
+ */
+ private static clienteSubastas buscar(String id, clienteSubastas[] cs){
+ clienteSubastas cl = null;
+ for (int i=0; i<cs.length; i++){
+ if (cs[i].identificacion().contains(id)){
+ cl = cs[i];
+ break;
+ }
+ }
+ return cl;
+ }
+
+ private static clienteSubastas crearCliente(String ident, POA poa){
+ org.omg.CORBA.Object obj = null;
+ clienteSubastasImpl cl1x = new clienteSubastasImpl(ident);
+ try {
+ obj = poa.servant_to_reference(cl1x);
+ } catch (Exception e1) {e1.printStackTrace();}
+
+ clienteSubastas cl1 = clienteSubastasHelper.narrow(obj);
+ return cl1;
+ }
+
+ public static void main(String[] args) throws IOException {
+ ORB orb = ORB.init(args, null);
+
+ LineNumberReader input = new LineNumberReader(new FileReader("server.ior"));
+ String ior = input.readLine();
+
+ org.omg.CORBA.Object obj = orb.string_to_object(ior);
+
+ gestorSubastas gs = gestorSubastasHelper.narrow(obj);
+
+ POA poa=null;
+ try{
+ //creacion del poa raiz
+ poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
+ //crear y activar sirvientes
+ poa.the_POAManager().activate();
+ }
+ catch (Exception e){e.printStackTrace();}
+
+ /**
+ * COMANDOS DISPONIBLES
+ *
+ * GESTOR SUBASTAS
+ * ---------------
+ * salir -> sale del bucle
+ * crear valor tiempo desc -> crea una subasta
+ * buscar desc -> busca una subasta y muestra todas las coincidencias
+ * borrar id -> borra una subasta si esta cerrada
+ *
+ * COORDINADOR SUBASTA
+ * -------------------
+ * abrir id -> abre la subasta por id
+ * estado id -> devuelve el estado de una subasta
+ * valor id -> devuelve el valor actual de una puja
+ * ganador_prov id -> dice el identificador del cliente que va ganando la puja
+ * ganador id -> muestra el ganador, si la puja no esta cerrada aun, bloquea al cliente
+ * clientes id -> muestra todos los identificadores de los clientes de la subasta
+ * inscribir id cliente_id -> inscribe un cliente en una subasta
+ * pujar id cliente_id valor
+ * ultima id cliente_id
+ *
+ * CLIENTE SUBASTAS
+ * ----------------
+ * crearcliente identificacion
+ * cldisp -> muestra los clientes disponibles
+ */
+
+ coordinadorSubasta[] subastas = null;
+ clienteSubastas[] clientes = new clienteSubastas[100];
+ int n_clientes = 0;
+
+ boolean salir = false;
+ String comando = "";
+ System.out.println("== INICIO ==");
+ while(!salir){
+ System.out.print(">>");
+ try{
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ comando = br.readLine();
+ }catch(Exception e){ e.printStackTrace();}
+ String[] partesDelComando = comando.split(" ");
+ if(comando.equals("salir")){
+ salir = true;
+ System.out.println("Adios ;)");
+ break;
+ }
+ else if(comando.equals("help")){
+ System.out.println(
+ "* COMANDOS DISPONIBLES\r\n" +
+ "*\r\n " +
+ "* GESTOR SUBASTAS\r\n"+
+ "* --------------\r\n"+
+ "* salir -> sale del bucle\r\n"+
+ "* crear valor tiempo desc -> crea una subasta\r\n"+
+ "* buscar desc -> busca una subasta y muestra todas las coincidencias\r\n"+
+ "* borrar id -> borra una subasta si esta cerrada\r\n"+
+ "* \r\n"+
+ "* COORDINADOR SUBASTA\r\n"+
+ "* -------------------\r\n"+
+ "* abrir id -> abre la subasta por id\r\n"+
+ "* estado id -> devuelve el estado de una subasta\r\n"+
+ "* valor id -> devuelve el valor actual de una puja\r\n"+
+ "* ganador_prov id -> dice el identificador del cliente que va ganando la puja\r\n"+
+ "* ganador id -> muestra el ganador, si la puja no esta cerrada aun, bloquea al cliente\r\n"+
+ "* clientes id -> muestra todos los identificadores de los clientes de la subasta\r\n"+
+ "* inscribir id cliente_id -> inscribe un cliente en una subasta\r\n"+
+ "* pujar id cliente_id valor\r\n"+
+ "* ultima id cliente_id\r\n"+
+ "* \r\n"+
+ "* CLIENTE SUBASTAS\r\n"+
+ "* ----------------\r\n"+
+ "* crearcliente identificacion\r\n"+
+ "* cldisp -> muestra los clientes disponibles\r\n");
+ }
+
+ // Opciones de gestorSubastas
+ else if(partesDelComando[0].equals("crear")){
+ String desc = "";
+ float valor = 0;
+ int time = 0;
+ valor = Float.valueOf(partesDelComando[1]);
+ time = Integer.valueOf(partesDelComando[2]);
+ for(int i=3; i<partesDelComando.length; i++){
+ desc += " "+partesDelComando[i];
+ }
+ coordinadorSubasta cs = gs.crearSubasta(valor, desc, time);
+ System.out.println("Subasta creada");
+ }
+ else if(partesDelComando[0].equals("buscar")){
+ String desc = "";
+ for(int i=1; i<partesDelComando.length; i++){
+ desc += " "+partesDelComando[i];
+ }
+
+ subastas = gs.localizarSubasta(desc);
+ for (int i=0; i<subastas.length; i++)
+ System.out.println(i+": "+subastas[i].descripcion()+" ("+subastas[i].valor()+") > " + subastas[i].estado());
+ }
+ else if(partesDelComando[0].equals("borrar")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ gs.destruirSubasta(subastas[id]);
+ System.out.println("Subasta borrada");
+ }
+
+ // Opciones de coordinadorSubasta
+ else if(partesDelComando[0].equals("abrir")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ subastas[id].abrirSubasta();
+ System.out.println(subastas[id].estado());
+ }
+ else if(partesDelComando[0].equals("estado")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ System.out.println(subastas[id].estado());
+ }
+ else if(partesDelComando[0].equals("valor")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ System.out.println(subastas[id].valor());
+ }
+ else if(partesDelComando[0].equals("ganador_prov")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ System.out.println(subastas[id].ganador_provisional().identificacion());
+ }
+ else if(partesDelComando[0].equals("ganador")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ System.out.println(subastas[id].ganador().identificacion());
+ }
+ else if(partesDelComando[0].equals("clientes")){
+ int id = 0;
+ id = Integer.valueOf(partesDelComando[1]);
+ clienteSubastas[] clientes2 = subastas[id].clientes();
+ for (int i=0; i< clientes2.length; i++){
+ System.out.println(i+": "+clientes2[i].identificacion());
+ }
+ }
+ else if(partesDelComando[0].equals("inscribir")){
+ int id = 0;
+ String cliente_id="";
+ clienteSubastas cl=null;
+ id = Integer.valueOf(partesDelComando[1]);
+ cliente_id = partesDelComando[2];
+ cl = buscar(cliente_id, clientes);
+ subastas[id].inscribirCliente(cl);
+ System.out.println("Cliente inscrito");
+ }
+
+ else if(partesDelComando[0].equals("pujar")){
+ int id = 0;
+ float valor = 0;
+ String cliente_id="";
+ clienteSubastas cl=null;
+ id = Integer.valueOf(partesDelComando[1]);
+ cliente_id = partesDelComando[2];
+ valor = Float.valueOf(partesDelComando[3]);
+ cl = buscar(cliente_id, clientes);
+ if(subastas[id].pujar(valor, cl))
+ System.out.println("Vas ganando");
+ else
+ System.out.println("No es suficiente");
+ }
+ else if(partesDelComando[0].equals("ultima")){
+ int id = 0;
+ String cliente_id="";
+ clienteSubastas cl=null;
+ id = Integer.valueOf(partesDelComando[1]);
+ cliente_id = partesDelComando[2];
+ cl = buscar(cliente_id, clientes);
+ subastas[id].ultimaPuja(cl);
+ System.out.println("Has dejado de pujar");
+ System.out.println(subastas[id].estado());
+ }
+
+ // creacion de clientes
+ else if(partesDelComando[0].equals("crearcliente")){
+ String id="";
+ clienteSubastas cl=null;
+ id = partesDelComando[1];
+ cl = crearCliente(id, poa);
+ clientes[n_clientes++] = cl;
+ }
+ else if(partesDelComando[0].equals("cldisp")){
+ for(int i=0; i<n_clientes; i++){
+ System.out.println(i+": "+clientes[i].identificacion());
+ }
+ }
+
+ }
+
+ System.out.println("FIN");
+ }
+
+}
+\end{lstlisting}
+
+\section{Anexos (Cliente python)}
+
+ Dado el interés que esta asignatura ha despertado en mí, me he
+ decidido a implementar un cliente en otro lenguaje diferente a
+ java para probar la interoperabilidad entre diferentes lenguajes
+ del middleware CORBA.
+
+ Después de implementar los sirvientes en java, la implementación
+ de un cliente en python que se conecte al servidor en java no ha
+ sido nada complicado.
+
+ Este cliente en python no es un cliente unificado sino que sólo
+ permite manejar un cliente que se puede inscribir a subastas y
+ pujar, no se pueden manejar las subastas desde este.
+
+\subsection{Código del cliente python}
+
+\subsubsection{cliente.py}
+\begin{lstlisting}[style=Python]
+
+#!/usr/bin/python
+
+import sys
+import CORBA, subastas
+import PortableServer
+from clienteSubastas_i import *
+
+orb = CORBA.ORB_init()
+ior = open('../server.ior').readline()
+
+gestor_subasta = orb.string_to_object(ior)
+
+poa = orb.resolve_initial_references("RootPOA")
+poa._get_the_POAManager().activate()
+
+
+def crear_cliente(id, poa):
+ cl = clienteSubastas_i(id)
+ cl1 = poa.servant_to_reference(cl)
+ return cl1
+
+subastas = gestor_subasta.localizarSubasta('')
+try:
+ nombre = sys.argv[1]
+except:
+ nombre = raw_input("nombre del cliente: ")
+cl = crear_cliente(nombre, poa)
+
+while True:
+ comando = raw_input(">>")
+ if comando.split()[0] == 'salir':
+ break
+ elif comando.split()[0] == 'inscribir':
+ subasta = subastas[int(comando.split()[1])]
+ subasta.inscribirCliente(cl)
+ elif comando.split()[0] == 'pujar':
+ subasta = subastas[int(comando.split()[1])]
+ valor = float(comando.split()[2])
+ if subasta.pujar(valor, cl):
+ print "Vas ganando"
+ else:
+ print "No es suficiente"
+ elif comando.split()[0] == 'ultima':
+ subasta = subastas[int(comando.split()[1])]
+ subasta.ultimaPuja(cl)
+ print "Has dejado de pujar"
+
+ elif comando.split()[0] == 'buscar':
+ try:
+ desc = comando.split()[1]
+ except:
+ desc = ''
+ subastas = gestor_subasta.localizarSubasta(desc)
+ for i,s in enumerate(subastas):
+ print i, s._get_descripcion(), s._get_estado()
+
+ elif comando.split()[0] == 'ganador':
+ subasta = subastas[int(comando.split()[1])]
+ print subasta.ganador()._get_identificacion()
+
+ elif comando.split()[0] == 'ganador_prov':
+ subasta = subastas[int(comando.split()[1])]
+ print subasta._get_ganador_provisional()._get_identificacion()
+
+ elif comando.split()[0] == 'estado':
+ subasta = subastas[int(comando.split()[1])]
+ print subasta._get_estado()
+
+ elif comando.split()[0] == 'valor':
+ subasta = subastas[int(comando.split()[1])]
+ print subasta._get_valor()
+
+ elif comando.split()[0] == 'clientes':
+ subasta = subastas[int(comando.split()[1])]
+ clientes = subasta._get_clientes()
+ for i, c in enumerate(clientes):
+ print i, c._get_identificacion()
+
+ elif comando.split()[0] == 'help':
+ help_str = '''
+ COMANDOS DISPONIBLES
+ --------------------
+ buscar desc -> muestra la lista de subastas
+ ganador id -> muestra el ganador de una subasta
+ inscribir id -> te inscribe en una puja
+ pujar id cantidad -> puja cantidad en la puja con id
+ ultima id -> dejas de pujar en la puja id
+ ganador_prov id -> muestra el ganador provisional
+ estado id -> muestra el estado de una puja
+ valor id -> muestra el valor actual de una puja
+ clientes id -> muestra los clientes que hay en una puja
+ salir -> sale del cliente
+ help -> muestra esta ayuda
+
+ '''
+ print help_str
+
+\end{lstlisting}
+
+\subsubsection{cliente.py}
+\begin{lstlisting}[style=Python]
+
+import subastas__POA
+
+class clienteSubastas_i(subastas__POA.clienteSubastas):
+ def __init__(self, id):
+ self.identificacion = id
+
+ def finSubasta(self):
+ pass
+
+ def nuevoValor(self, valor):
+ print "NUEVO VALOR: ", valor
+
+ def _get_identificacion(self):
+ return self.identificacion
+
+\end{lstlisting}
+
+\end{document}
projects / pcd.git / commitdiff