java.rmi.server.Operation Java Examples

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

/**
 * Handle server-side dispatch using the RMI 1.1 stub/skeleton
 * protocol, given a non-negative operation number or negative method hash
 * that has already been read from the call stream.
 * Exceptions are handled by the caller to be sent to the remote client.
 *
 * @param obj the target remote object for the call
 * @param call the "remote call" from which operation and
 * method arguments can be obtained.
 * @param op the operation number
 * @throws Exception if unable to marshal return result or
 * release input or output streams
 */
private void oldDispatch(Remote obj, RemoteCall call, int op)
    throws Exception
{
    long hash;              // hash for matching stub with skeleton

    // read remote call header
    ObjectInput in;
    in = call.getInputStream();
    try {
        Class<?> clazz = Class.forName("sun.rmi.transport.DGCImpl_Skel");
        if (clazz.isAssignableFrom(skel.getClass())) {
            ((MarshalInputStream)in).useCodebaseOnly();
        }
    } catch (ClassNotFoundException ignore) { }

    try {
        hash = in.readLong();
    } catch (Exception ioe) {
        throw new UnmarshalException("error unmarshalling call header", ioe);
    }

    // if calls are being logged, write out object id and operation
    Operation[] operations = skel.getOperations();
    logCall(obj, op >= 0 && op < operations.length ?  operations[op] : "op: " + op);
    unmarshalCustomCallData(in);
    // dispatch to skeleton for remote object
    skel.dispatch(obj, call, op, hash);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new UnsupportedOperationException();
}
 

public RemoteCall newCall(RemoteObject obj,
                          Operation[] op,
                          int opnum,
                          long hash)
{
    throw new AssertionError();
}
 

/**
 * This call is used by the old 1.1 stub protocol and is
 * unsupported since activation requires 1.2 stubs.
 */
public synchronized RemoteCall newCall(RemoteObject obj,
                                       Operation[] ops,
                                       int opnum,
                                       long hash)
    throws RemoteException
{
    throw new UnsupportedOperationException(versionComplaint);
}
 

/**
 * Handle server-side dispatch using the RMI 1.1 stub/skeleton
 * protocol, given a non-negative operation number or negative method hash
 * that has already been read from the call stream.
 * Exceptions are handled by the caller to be sent to the remote client.
 *
 * @param obj the target remote object for the call
 * @param call the "remote call" from which operation and
 * method arguments can be obtained.
 * @param op the operation number
 * @throws Exception if unable to marshal return result or
 * release input or output streams
 */
private void oldDispatch(Remote obj, RemoteCall call, int op)
    throws Exception
{
    long hash;              // hash for matching stub with skeleton

    // read remote call header
    ObjectInput in;
    in = call.getInputStream();
    try {
        Class<?> clazz = Class.forName("sun.rmi.transport.DGCImpl_Skel");
        if (clazz.isAssignableFrom(skel.getClass())) {
            ((MarshalInputStream)in).useCodebaseOnly();
        }
    } catch (ClassNotFoundException ignore) { }

    try {
        hash = in.readLong();
    } catch (Exception ioe) {
        throw new UnmarshalException("error unmarshalling call header", ioe);
    }

    // if calls are being logged, write out object id and operation
    Operation[] operations = skel.getOperations();
    logCall(obj, op >= 0 && op < operations.length ?  operations[op] : "op: " + op);
    unmarshalCustomCallData(in);
    // dispatch to skeleton for remote object
    skel.dispatch(obj, call, op, hash);
}