Name: gm110360 Date: 05/30/2002


FULL PRODUCT VERSION :
java version "1.4.0-rc"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.0-rc-b91)
Java HotSpot(TM) Client VM (build 1.4.0-rc-b91, mixed mode)

FULL OPERATING SYSTEM VERSION :
Microsoft Windows 2000 [Version 5.00.2195]

ADDITIONAL OPERATING SYSTEMS :
All I think



A DESCRIPTION OF THE PROBLEM :
When you write a client server application using CORBA, you
often have to throw a user exception.
When you throw an server-side exception with a message, you
want to receive this same message on the client side.
By defining the most simple exception in the IDL, the IDL
compiler generates a constructor that takes a String for
the message but this String is NEVER sent from the client
to the server, the only thing that is sent is the Exception
id.
So my question is what is the point of this constructor
with a message if there is no way to get the message at the
other end?

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
1. write a simple idl with an exception Ex and an interface
In with a method that throws this exception
2. write a server that instantiate an ORB, and that
activates a In servant. The implementation of the In
servant should throws an Ex exception
3. write a client that contacts the ORB, ask for the In
object and calls its method

EXPECTED VERSUS ACTUAL BEHAVIOR :
if the In interface throws:
new Ex("this is a message")

the client will catch an Ex instance and
exInstance.getMessage() will return the IDL id instead of
the "this is a message" message

This bug can be reproduced always.

---------- BEGIN SOURCE ----------
There are 4 little files:
bug.idl : the minimalistic IDL file
ThrowerImpl.java : the implementation of the servant
Server.java : the server
Test.java : a client

-----> bug.idl

module bug {

exception MyException {
};

interface Thrower {

void throwMe(in string _message) raises (MyException);

};

};

-----> ThrowerImpl.java

import bug.*;

import org.omg.PortableServer.*;
import org.omg.PortableServer.POAPackage.*;

class ThrowerImpl extends ThrowerPOA {
public void throwMe (String _message) throws bug.MyException {
MyException e = new MyException(_message);
System.out.println("message: "+e.getMessage());
throw e;
}
}

-----> Server.java

import bug.*;

import org.omg.CORBA.ORB;
import org.omg.PortableServer.*;
import org.omg.CORBA.portable.*;
import org.omg.CosNaming.*;

class Server {

private static Server server;
private static ORB orb = null;
private String orbInitialHost = "localhost";
private String orbInitialPort = "1050";

public Server() {
// create servants
ThrowerImpl throwerServant = new ThrowerImpl();

try {
// create and initialize the ORB
String[] orbArgs = {"-ORBInitialPort",
orbInitialPort, "-ORBInitialHost", orbInitialHost};
orb = ORB.init(orbArgs, null);

// get reference to rootpoa & activate the POAManager
POA rootpoa = (POA)orb.resolve_initial_references
("RootPOA");

// activate servants
rootpoa.activate_object(throwerServant);

//---------- start registration on naming service
// get the root naming context
// NameService invokes the transient name service
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
// Use NamingContextExt which is part of the
Interoperable
// Naming Service (INS) specification.
NamingContextExt ncRef = NamingContextExtHelper.narrow
(objRef);

// get object reference from the servant
org.omg.CORBA.Object ref1 = rootpoa.servant_to_reference
(throwerServant);
Thrower href1 = ThrowerHelper.narrow(ref1);

// bind the Object Reference in Naming
String name1 = "TheThrower";
NameComponent path1[] = ncRef.to_name( name1 );
ncRef.rebind(path1, href1);
//---------- end of registration on naming service

//activate POA
rootpoa.the_POAManager().activate();
} catch(Exception e) {
System.err.println(e.getClass().getName()+": " +
e.toString()+" : "+e.getMessage());
System.exit(0);
}

}

public static void main(String args[]) {
server = new Server();
orb.run();
}

}

-----> Test.java

import bug.*;

import org.omg.CosNaming.*;
import org.omg.CORBA.*;

public class Test
{

private static NamingContextExt ncRef = null;

public static void main(String args[]) {

try {
// create and initialize the ORB
ORB orb = ORB.init(args, null);

// get the root naming context
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
// Use NamingContextExt instead of NamingContext. This
is
// part of the Interoperable naming Service.
ncRef = NamingContextExtHelper.narrow(objRef);

Thrower theThrower = ThrowerHelper.narrow
(ncRef.resolve_str("TheThrower"));
theThrower.throwMe("Looks like a bug to me!");
} catch (Exception e) {
System.err.println(e.getClass().getName()
+": "+e.getMessage());
System.exit(0);
}
}

}

---------- END SOURCE ----------
(Review ID: 139007)
======================================================================