com.sun.corba.se.impl.encoding.CDRInputObject Java Examples

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

protected String peekUserExceptionId(InputObject inputObject)
{
    CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
    // REVISIT - need interface for mark/reset
    cdrInputObject.mark(Integer.MAX_VALUE);
    String result = cdrInputObject.read_string();
    cdrInputObject.reset();
    return result;
}
 

public void responseReceived(InputObject is)
{
    CDRInputObject inputObject = (CDRInputObject) is;
    LocateReplyOrReplyMessage header = (LocateReplyOrReplyMessage)
        inputObject.getMessageHeader();
    Integer requestId = new Integer(header.getRequestId());
    OutCallDesc call = out_calls.get(requestId);

    if (orb.transportDebugFlag) {
        dprint(".responseReceived: id/"
               + requestId  + ": "
               + header);
    }

    // This is an interesting case.  It could mean that someone sent us a
    // reply message, but we don't know what request it was for.  That
    // would probably call for an error.  However, there's another case
    // that's normal and we should think about --
    //
    // If the unmarshaling thread does all of its work inbetween the time
    // the ReaderThread gives it the last fragment and gets to the
    // out_calls.get line, then it will also be null, so just return;
    if (call == null) {
        if (orb.transportDebugFlag) {
            dprint(".responseReceived: id/"
                   + requestId
                   + ": no waiter: "
                   + header);
        }
        return;
    }

    // Set the reply InputObject and signal the client thread
    // that the reply has been received.
    // The thread signalled will remove outcall descriptor if appropriate.
    // Otherwise, it'll be removed when last fragment for it has been put on
    // BufferManagerRead's queue.
    synchronized (call.done) {
        CorbaMessageMediator messageMediator = (CorbaMessageMediator)
            call.messageMediator;

        if (orb.transportDebugFlag) {
            dprint(".responseReceived: "
                   + opAndId(messageMediator)
                   + ": notifying waiters");
        }

        messageMediator.setReplyHeader(header);
        messageMediator.setInputObject(is);
        inputObject.setMessageMediator(messageMediator);
        call.inputObject = is;
        call.done.notify();
    }
}
 

public void handleInput(FragmentMessage_1_2 header) throws IOException
{
    try {
        try {
            messageHeader = header;

            // Note:  We know it's a 1.2 fragment, we have the data, but
            // we need the IIOPInputStream instance to unmarshal the
            // request ID... but we need the request ID to get the
            // IIOPInputStream instance. So we peek at the raw bytes.

            header.unmarshalRequestID(dispatchByteBuffer);

            if (transportDebug()) {
                dprint(".FRAGMENT 1.2->: id/"
                       + header.getRequestId()
                       + ": more?: " + header.moreFragmentsToFollow()
                       + ": " + header);
            }

            MessageMediator mediator = null;
            InputObject inputObject = null;

            if (connection.isServer()) {
                mediator =
                    connection.serverRequestMapGet(header.getRequestId());
            } else {
                mediator =
                    connection.clientRequestMapGet(header.getRequestId());
            }
            if (mediator != null) {
                inputObject = mediator.getInputObject();
            }
            // See 1.1 comments.
            if (inputObject == null) {
                if (transportDebug()) {
                    dprint(".FRAGMENT 1.2: id/"
                           + header.getRequestId()
                           + ": ++++DISCARDING++++: "
                           + header);
                }
                // need to release dispatchByteBuffer to pool if
                // we are discarding
                releaseByteBufferToPool();
                return;
            }
            ((CDRInputObject)inputObject)
                .getBufferManager().processFragment(
                                 dispatchByteBuffer, header);

            // REVISIT: but if it is a server don't you have to remove the
            // stream from the map?
            if (! connection.isServer()) {
                /* REVISIT
                 * No need to do anything.
                 * Should we mark that last was received?
                 if (! header.moreFragmentsToFollow()) {
                 // Last fragment.
                 }
                */
            }
        } finally {
            // NOTE: This *must* come after queing the fragment
            // when using the selector to ensure fragments stay in order.
            setWorkThenReadOrResumeSelect(header);
        }
    } catch (Throwable t) {
        if (transportDebug())
            dprint(".FRAGMENT 1.2: id/"
                   + header.getRequestId()
                   + ": !!ERROR!!: "
                   + header, t);
        // Mask the exception from thread.;
    } finally {
        if (transportDebug()) dprint(".FRAGMENT 1.2<-: id/"
                                     + header.getRequestId()
                                     + ": "
                                     + header);
    }
}
 

protected void handleRequestRequest(CorbaMessageMediator messageMediator)
{
    // Does nothing if already unmarshaled.
    ((CDRInputObject)messageMediator.getInputObject()).unmarshalHeader();

    ORB orb = (ORB)messageMediator.getBroker();
    synchronized (orb) {
        orb.checkShutdownState();
    }

    ObjectKey okey = messageMediator.getObjectKey();
    if (orb.subcontractDebugFlag) {
        ObjectKeyTemplate oktemp = okey.getTemplate() ;
        dprint( ".handleRequest: " + opAndId(messageMediator)
                + ": dispatching to scid: " + oktemp.getSubcontractId());
    }

    CorbaServerRequestDispatcher sc = okey.getServerRequestDispatcher(orb);

    if (orb.subcontractDebugFlag) {
        dprint(".handleRequest: " + opAndId(messageMediator)
               + ": dispatching to sc: " + sc);
    }

    if (sc == null) {
        throw wrapper.noServerScInDispatch() ;
    }

    // NOTE:
    // This is necessary so mediator can act as ResponseHandler
    // and pass necessary info to response constructors located
    // in the subcontract.
    // REVISIT - same class right now.
    //messageMediator.setProtocolHandler(this);

    try {
        orb.startingDispatch();
        sc.dispatch(messageMediator);
    } finally {
        orb.finishedDispatch();
    }
}
 

public void signalExceptionToAllWaiters(SystemException systemException)
{

    if (orb.transportDebugFlag) {
        dprint(".signalExceptionToAllWaiters: " + systemException);
    }

    synchronized (out_calls) {
        if (orb.transportDebugFlag) {
            dprint(".signalExceptionToAllWaiters: out_calls size :" +
                   out_calls.size());
        }

        for (OutCallDesc call : out_calls.values()) {
            if (orb.transportDebugFlag) {
                dprint(".signalExceptionToAllWaiters: signaling " +
                        call);
            }
            synchronized(call.done) {
                try {
                    // anything waiting for BufferManagerRead's fragment queue
                    // needs to be cancelled
                    CorbaMessageMediator corbaMsgMediator =
                                 (CorbaMessageMediator)call.messageMediator;
                    CDRInputObject inputObject =
                               (CDRInputObject)corbaMsgMediator.getInputObject();
                    // IMPORTANT: If inputObject is null, then no need to tell
                    //            BufferManagerRead to cancel request processing.
                    if (inputObject != null) {
                        BufferManagerReadStream bufferManager =
                            (BufferManagerReadStream)inputObject.getBufferManager();
                        int requestId = corbaMsgMediator.getRequestId();
                        bufferManager.cancelProcessing(requestId);
                    }
                } catch (Exception e) {
                } finally {
                    // attempt to wake up waiting threads in all cases
                    call.inputObject = null;
                    call.exception = systemException;
                    call.done.notifyAll();
                }
            }
        }
    }
}
 

public void responseReceived(InputObject is)
{
    CDRInputObject inputObject = (CDRInputObject) is;
    LocateReplyOrReplyMessage header = (LocateReplyOrReplyMessage)
        inputObject.getMessageHeader();
    Integer requestId = new Integer(header.getRequestId());
    OutCallDesc call = out_calls.get(requestId);

    if (orb.transportDebugFlag) {
        dprint(".responseReceived: id/"
               + requestId  + ": "
               + header);
    }

    // This is an interesting case.  It could mean that someone sent us a
    // reply message, but we don't know what request it was for.  That
    // would probably call for an error.  However, there's another case
    // that's normal and we should think about --
    //
    // If the unmarshaling thread does all of its work inbetween the time
    // the ReaderThread gives it the last fragment and gets to the
    // out_calls.get line, then it will also be null, so just return;
    if (call == null) {
        if (orb.transportDebugFlag) {
            dprint(".responseReceived: id/"
                   + requestId
                   + ": no waiter: "
                   + header);
        }
        return;
    }

    // Set the reply InputObject and signal the client thread
    // that the reply has been received.
    // The thread signalled will remove outcall descriptor if appropriate.
    // Otherwise, it'll be removed when last fragment for it has been put on
    // BufferManagerRead's queue.
    synchronized (call.done) {
        CorbaMessageMediator messageMediator = (CorbaMessageMediator)
            call.messageMediator;

        if (orb.transportDebugFlag) {
            dprint(".responseReceived: "
                   + opAndId(messageMediator)
                   + ": notifying waiters");
        }

        messageMediator.setReplyHeader(header);
        messageMediator.setInputObject(is);
        inputObject.setMessageMediator(messageMediator);
        call.inputObject = is;
        call.done.notify();
    }
}