src.com.ibm.as400.access.PxMethodReqSV Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk8 Show documentation
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: PxMethodReqSV.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2000 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
The PxMethodReqSV class represents the
server view of a method request.
**/
class PxMethodReqSV
extends PxReqSV
{
private static final String copyright = "Copyright (C) 1997-2000 International Business Machines Corporation and others.";
// Private data.
private PxTable pxTable_;
//@B2D private PSConnection connection_;
public PxMethodReqSV(PxTable pxTable) //@B2D, PSConnection connection)
{
super (ProxyConstants.DS_METHOD_REQ);
pxTable_ = pxTable;
//@B2Dconnection_ = connection;
}
static Object invoke(Object object,
String methodName,
Class[] argumentClasses,
Object[] arguments)
throws ClassNotFoundException,
IllegalAccessException,
InvocationTargetException,
NoSuchMethodException
{
// Resolve the Method object. First, try Class.getMethod() which
// only looks for public methods. If that does not work, try
// Class.getDeclaredMethod(), which only looks for declared
// methods (not inherited methods). Do this up the superclass tree.
if (Trace.isTraceProxyOn()) {
Trace.log (Trace.INFORMATION, "PxMethodReqSV calling object="+object);
Trace.log (Trace.INFORMATION, " objectClass="+object.getClass().toString());
Trace.log (Trace.INFORMATION, " methodName="+methodName);
for (int i = 0; i < argumentClasses.length; i++) {
Trace.log (Trace.INFORMATION, " argClass["+i+"]="+argumentClasses[i].toString());
}
}
Method method = null;
Class clazz = object.getClass();
NoSuchMethodException e = null;
while ((clazz != null) && (method == null)) {
try {
method = clazz.getMethod(methodName, argumentClasses);
}
catch (NoSuchMethodException e1) {
try {
method = clazz.getDeclaredMethod(methodName, argumentClasses);
}
catch (NoSuchMethodException e2) {
e = e2;
clazz = clazz.getSuperclass();
}
}
}
if (method == null)
throw e;
// Call the method.
Object o = null;
try {
o = method.invoke (object, arguments);
} catch (IllegalAccessException ex) {
if (Trace.isTraceInformationOn()) {
for (int i = 0; i < arguments.length; i++) {
String argString = ""+arguments[i];
Trace.log (Trace.INFORMATION, " arguments["+i+"]="+ argString);
}
}
throw ex;
} catch (InvocationTargetException ex) {
throw ex;
}
return o;
}
public PxRepSV process()
{
try {
// Get the information from the datastream parameters.
int p = -1;
Object proxy = ((PxPxObjectParm) getParm (++p)).getObjectValue ();
String methodName = ((PxStringParm) getParm (++p)).getStringValue ();
boolean factory = ((PxBooleanParm) getParm (++p)).getBooleanValue ();
int argumentCount = ((PxIntParm) getParm (++p)).getIntValue ();
Class[] argumentClasses = new Class[argumentCount];
for (int i = 0; i < argumentCount; ++i)
argumentClasses[i] = ((PxClassParm) getParm (++p)).getClassValue ();
Object[] arguments = new Object[argumentCount];
for (int i = 0; i < argumentCount; ++i)
arguments[i] = ((PxParm) getParm (++p)).getObjectValue ();
boolean[] returnArguments = new boolean[argumentCount];
for (int i = 0; i < argumentCount; ++i)
returnArguments[i] = ((PxBooleanParm)getParm(++p)).getBooleanValue();
// There is a chance that the proxy object is null here. It is rare,
// but it can happen if the client called a method then finalized
// immediately following, and the proxy server gets a method call AFTER
// the finalize so the object is gone by that point.
Object returnValue = null;
if (proxy != null) {
// Invoke the method and return the value. If the method
// creates a proxy object, we need to add it to the proxy
// table.
returnValue = invoke (proxy, methodName, argumentClasses, arguments);
if ((factory) && (returnValue != null))
pxTable_.add (returnValue);
}
return new PxReturnRepSV (pxTable_, returnValue, arguments, returnArguments);
}
catch (InvocationTargetException e) {
if (Trace.isTraceErrorOn () || Trace.isTraceProxyOn()) {
Trace.log(Trace.ERROR, "Caught InvocationTargetException "+e);
}
return new PxExceptionRepSV (e.getTargetException ());
}
catch (Exception e) {
if (Trace.isTraceErrorOn () || Trace.isTraceProxyOn()) {
Trace.log(Trace.ERROR, this+": Caught Exceptionn ");
Trace.log (Trace.ERROR, e.toString (), e);
}
// If a method can not be called, there is a good chance that a mod x+1 @A1A
// client is connecting to a mod x proxy server. This is bad, but we @A1A
// don't want to kill the whole proxy server as a result. Therefore, @A1A
// we will return the exception to the client. @A1A
return new PxExceptionRepSV(new ProxyException(ProxyException.VERSION_MISMATCH)); // @A1C @B1C
}
}
}