Overview | Package | Class | Use | Tree | Deprecated | Index | Help
|  | Oracle
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## weblogic.wtc.gwt
Class TuxedoConnection

    java.lang.Object
      weblogic.wtc.gwt.TuxedoConnection

All Implemented Interfaces:
  ApplicationToMonitorInterface

    public class TuxedoConnection

extends Object
implements ApplicationToMonitorInterface

These are the methods that clients call in order to get access to remote domains.

Field Summary

Fields inherited from interface weblogic.wtc.jatmi.ApplicationToMonitorInterface
`TPABSOLUTE, TPACK, TPAPPAUTH, TPCONV, TPGETANY, TPNOAUTH, TPNOBLOCK, TPNOCHANGE, TPNOREPLY, TPNOTIME, TPNOTRAN, TPRECVONLY, TPRMICALL, TPSENDONLY, TPSIGRSTRT, TPSYSAUTH, TPTRAN, TPUNKAUTH`

Method Summary
`CallDescriptor` | `tpacall(String svc, TypedBuffer data, int flags)` This calls the other tpacall with null as the reply object
`CallDescriptor` | `tpacall(String svc, TypedBuffer data, int flags, TpacallAsyncReply callBack)` This implementation of tpacall is aware of the domain configuration files which correlate services with local and remote domains.
`Reply` | `tpcall(String svc, TypedBuffer data, int flags)` This implementation of tpcall looks up the proper service using the domain configuration files and/or MBeans.
`void` | `tpcancel(CallDescriptor cd, int flags)` This implementation knows about the tuxedo call descriptor and will attempt to cancel the outstanding tpacall request.
`Conversation` | `tpconnect(String svc, TypedBuffer data, int flags)` This implementation of tpconnect looks up the proper service using the domain configuration files and/or MBeans.
`DequeueReply` | `tpdequeue(String qspace, String qname, byte[] msgid, byte[] corrid, boolean doWait, boolean doPeek, int flags)` Much like tpacall, this looks up the remote qspace as a service offered through the domain configuration file, and once it has located the proper remote domain through which to send the dequeue request, it sends it.
`DequeueReply` | `tpdequeue(String qspace, String qname, int flags)` This is the simple version of tpdequeue, which is equalvalent to calling the other tpdequeue verb with null as the msgid and corrid and false as the values for doWait and doPeek.
`byte[]` | `tpenqueue(String qspace, String qname, EnqueueRequest ctl, TypedBuffer data, int flags)` Much like tpacall, this looks up the remote qspace as a service offered through the domain configuration file, and once it has located the proper remote domain through which to send the enqueue request, it sends it.
`Reply` | `tpgetrply(CallDescriptor cd, int flags)` This implementation does not yet handle the case of blocking replies with the TPGETANY flag.
`void` | `tpsprio(int prio, int flags)` Sets the priority for the next request sent or forwarded by the current thread in the current context.
`void` | `tpterm()` This should be called by applications when they are finished with operations on this object.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### tpacall

    public CallDescriptor tpacall(String svc,
                                  TypedBuffer data,
                                  int flags)
                           throws TPException

  This calls the other tpacall with null as the reply object

  Specified by:
    `tpacall` in interface `ApplicationToMonitorInterface`
  Parameters:
    `svc` - The name of the Tuxedo service
    `data` - Pointer to the data buffer; null specifies no data sent
    `flags` -
    - TPNOTRAN: Specifies if the caller is in transaction mode when `svc` is invoked, the call does not becoome part of the caller's transaction. If `svc` belongs to a server that does not support transactions, this flag must be set when the caller is in transaction mode. Note that `svc` may still be invoked in transaction mode but it will not be the same transaction: a `svc` may have a configuration attribute that it is automatically invoked in transaction mode. A caller in transaction mode that sets this flag is still subject to the transaction timeout (and no other). If a service fails that was invoked with this flag, the caller's transaction is not affected.
    - TPNOREPLY: Specifies a reply is not expected. When set, a call returns 0 on success, where 0 is not a valid descriptor. When the caller is in transaction mode, this setting can only be used if TPNOTRAN is also set.
    - TPNOBLOCK: Specifies this request is not sent if a blocking condition exists. For example, a blocking condition exits if the internal buffers into which this message is transferred is full. If TPNOBLOCK is not specified and a blocking condition exists, the caller blocks until the condition subsides, a transaction timeout occurs, or a blocking timeout occurs.
    - TPNOTIME: Specifies this caller blocks indefinitely and is immune from blocking timeouts but remains subject to transaction timeouts.
  Returns:
    Returns an object that serves as a descriptor. You can use the call descriptor to:
    - Get the correct reply for the sent request using `tpgetreply` or
    - Cancel an outstanding message reply using `tpcancel`.
  Throws:
    `TPException` - Returns a TPException indicating the error condition. `tperrno` is set to one of the following values:
    - TPEINVAL: Invalid arguments given. For example, `svc` is null or flags are invalid.
    - TPENOENT: Indicates `svc` does not exist or is a conversational service.
    - TPEITYPE: Indicates the type and sub-type of `data` does not match the type and sub-type expected by `svc`.
    - TPELIMIT: Indicates the request failed because the maximum number of outstanding asynchronous requests has been reached.
    - TPETRAN: Indicates `svc` belongs to a server that does not support transactions and TPNOTRAN was not set.
    - TPETIME: Indicates a timeout occurred. If the caller is in transaction mode, then a transaction timeout occurred and the transaction is marked abort-only:
      - Any attempt to send new requests or receive outstanding replies will fail with TPETIME until the transaction is aborted.
      - The only exception is a request that does not block, expects no reply, and is not sent on behalf of the caller's transaction - `tpacall` with TPNOTRAN, TPNOBLOCK, and TPNOREPLY set.
      Otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified.
    - TPEBLOCK: Indicates a blocking condition exists and TPNOBLOCK is specified.
    - TPEPROTO: Indicates `tpacall` was called improperly.
    - TPESYSTEM: A BEA Tuxedo system error occurred. The exact nature of the error is written to a log file.
    - TPEOS: An operating system error occurred. If a message queue on a remote location is filled, TPEOS may be returned even if `tpacall` returned successfully.

### tpacall

    public CallDescriptor tpacall(String svc,
                                  TypedBuffer data,
                                  int flags,
                                  TpacallAsyncReply callBack)
                           throws TPException

  This implementation of tpacall is aware of the domain configuration files which correlate services with local and remote domains. It gets the table of services from a static WTCService method, and uses that to look up the proper local and then remote domain to which to route this object. It takes care of all of the data dependent routing, and failover/failback logic. Once the proper remote domain has been chosen, it does the tpacall to the remote domain, returning an object that can be used in subsequent calls to tpgetrply.

  Specified by:
    `tpacall` in interface `ApplicationToMonitorInterface`
  Parameters:
    `svc` - same as ApplicationToMonitorInterface interface
    `data` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
    `callBack` - The object to invoke when the service reply is ready. If the original request succeeded, the `TpacallAsynchReply.sucess` method returns the reply from the service. If the original request failed, the `TpacallAsynchReply.failure` method returns a failure code. If null, the request becomes a deferred asyncronous `tpacall`.
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - Returns a TPException indicating the error condition. If an exception is thrown by this method the callBack will not be invoked. `tperrno` is set to one of the following values:
    - TPEINVAL: Invalid arguments given. For example, `svc` is null or flags are invalid.
    - TPENOENT: Indicates `svc` does not exist or is a conversational service.
    - TPEITYPE: Indicates the type and sub-type of `data` does not match the type and sub-type expected by `svc`.
    - TPELIMIT: Indicates the request failed because the maximum number of outstanding asynchronous requests has been reached.
    - TPETRAN: Indicates `svc` belongs to a server that does not support transactions and TPNOTRAN was not set.
    - TPETIME: Indicates a timeout occurred. If the caller is in transaction mode, then a transaction timeout occurred and the transaction is marked abort-only:
      - Any attempt to send new requests or receive outstanding replies will fail with TPETIME until the transaction is aborted.
      - The only exception is a request that does not block, expects no reply, and is not sent on behalf of the caller's transaction - `tpacall` with TPNOTRAN, TPNOBLOCK, and TPNOREPLY set.
      Otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified.
    - TPEBLOCK: Indicates a blocking condition exists and TPNOBLOCK is specified.
    - TPEPROTO: Indicates `tpacall` was called improperly.
    - TPESYSTEM: A BEA Tuxedo system error occurred. The exact nature of the error is written to a log file.
    - TPEOS: An operating system error occurred. If a message queue on a remote location is filled, TPEOS may be returned even if `tpacall` returned successfully.

### tpcancel

    public void tpcancel(CallDescriptor cd,
                         int flags)
                  throws TPException

  This implementation knows about the tuxedo call descriptor and will attempt to cancel the outstanding tpacall request. If it cannot, it will throw an exception

  Specified by:
    `tpcancel` in interface `ApplicationToMonitorInterface`
  Parameters:
    `cd` - Call descriptor returned by a deferred or ansyncronous tpacall.
    `flags` - Must be zero
  Throws:
    `TPException`

### tpgetrply

    public Reply tpgetrply(CallDescriptor cd,
                           int flags)
                    throws TPException,
                           TPReplyException

  This implementation does not yet handle the case of blocking replies with the TPGETANY flag. The problem is that the reply may span more than one remote domain, and the only way to handle that is either with threads at this layer or by getting support from the lower layer for a multi-remote domain reply architecture, which I favor. Hence, this implementation is only in order so that we can get our feet wet, and smoke out some of the other WLS integration issues that are sure to arise.

  Specified by:
    `tpgetrply` in interface `ApplicationToMonitorInterface`
  Parameters:
    `cd` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - Upon failure `tpgetrply` throws `TPException` to indicate the error condition. tperrno in TPException will be set to one of the following values:
    - TPEINVAL: Invalid arguments were given. For example: `cd` or `flags` are invalid.
    - TPEOTYPE: The type and sub-type of the reply are not known to the caller. If the reply was to be received on behalf of the caller's current transaction, then the transaction is marked abort-only as the reply is discarded.
    - TPEBADDESC: `cd` points to an invalid descriptor.
    - TPETIME: A timeout occurred. If the caller is in transaction mode, then a transaction timeout occurred and the transaction is marked abort-only. Otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME were specified. If a transaction timeout occurred, then with one exception, any attempts to send new requests or receive outstanding replies will fail with TPETIME until the transaction has been aborted. The exception is a request that does not block, expects no reply and is not sent on behalf of the caller's transaction - `tpacall` with TPNOTRAN, TPNOBLOCK and TPNOREPLY set.
    - TPEBLOCK: A blocking condition exists and TPNOBLOCK was specified.
    - TPEPROTO: `tpgetrply` was called improperly.
    - TPESYSTEM: A BEA Tuxedo system error has occurred. The exact nature of the error is written to a log file.
    - TPEOS: An operating system error has occurred. If a message queue on a remote location is filled, TPEOS may be returned.
    `TPReplyException` - If there is a service failure (TPESVCFAIL or TPSVCERROR) in which case the exception will also have reply data from the service. However, unlike the `tpcall` case, this execption may also be thrown in any of the above TPException cases as well, so that specific TPException return codes can be matched with the request object returned from `tpacall`. If TPReplyException is thrown then it is on behalf of an outstanding request and that request is considered to have completed with a failure.

### tpenqueue

    public byte[] tpenqueue(String qspace,
                            String qname,
                            EnqueueRequest ctl,
                            TypedBuffer data,
                            int flags)
                     throws TPException

  Much like tpacall, this looks up the remote qspace as a service offered through the domain configuration file, and once it has located the proper remote domain through which to send the enqueue request, it sends it.

  Specified by:
    `tpenqueue` in interface `ApplicationToMonitorInterface`
  Parameters:
    `qspace` - same as ApplicationToMonitorInterface interface
    `qname` - same as ApplicationToMonitorInterface interface
    `ctl` - same as ApplicationToMonitorInterface interface
    `data` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - Upon failure, tpenqueue() sets tperrno in TPException to one of the following values (unless otherwise noted, failure does not affect the callers transaction, if one exists)
    - TPEINVAL Invalid arguments were given (for example, qspace is null or flags are invalid).
    - TPENOENT Cannot access the qspace because it is not available (that is, the associated TMQUEUE(5) server is not available), or cannot start a global transaction due to the lack of entries in the Global Transaction Table (GTT).
    - TPETIME A timeout occurred. If the caller is in transaction mode, a transaction timeout occurred and the transaction is to be aborted; otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified. If a transaction timeout occurred, any attempts to enqueue new messages will fail with TPETIME until the transaction has been aborted.
    - TPEBLOCK A blocking condition exists and TPNOBLOCK was specified.
    - TPEPROTO tpenqueue() was called improperly.
    - TPESYSTEM A BEA Tuxedo system error has occurred. The exact nature of the error is written to a log file.
    - TPEOS An operating system error has occurred.
    - TPEDIAGNOSTIC One of the following values is available in the diagnostic field of the execption:
      - QMEINVAL An invalid flag value was specified.
      - QMEBADRMID An invalid resource manager identifier was specified.
      - QMENOTOPEN The resource manager is not currently open.
      - QMETRAN The call was not in transaction mode or was made with the TPNOTRAN flag set and an error occurred trying to start a transaction in which to enqueue the message. This diagnostic is not returned by queue managers from BEA Tuxedo Release 7.1 or later.
      - QMEBADMSGID An invalid message identifier was specified.
      - QMESYSTEM A system error occurred. The exact nature of the error is written to a log file.
      - QMEOS An operating system error occurred.
      - QMEABORTED The operation was aborted. When executed within a global transaction, the global transaction has been marked rollback-only. Otherwise, the queue manager aborted the operation.
      - QMEPROTO An enqueue was done when the transaction state was not active.
      - QMEBADQUEUE An invalid or deleted queue name was specified.
      - QMENOSPACE Due to an insufficient resource, such as no space on the queue, the message with its required quality of service (persistent or non-persistent storage) was not enqueued. QMENOSPACE is returned when any of the following configured resources is exceeded: (1) the amount of disk (persistent) space allotted to the queue space, (2) the amount of memory (non-persistent) space allotted to the queue space, (3) the maximum number of simultaneously active transactions allowed for the queue space, (4) the maximum number of messages that the queue space can contain at any one time, (5) the maximum number of concurrent actions that the Queuing Services component can handle, or (6) the maximum number of authenticated users that may concurrently use the Queuing Services component.
      - QMERELEASE An attempt was made to enqueue a message to a queue manager that is from a version of the BEA Tuxedo system that does not support a newer feature.
      - QMESHARE When enqueuing a message from a specified queue, the specified queue is opened exclusively by another application. The other application is one based on a BEA product other than the BEA Tuxedo system that opened the queue for exclusive read and/or write using the Queuing Services API (QSAPI).

### tpdequeue

    public DequeueReply tpdequeue(String qspace,
                                  String qname,
                                  byte[] msgid,
                                  byte[] corrid,
                                  boolean doWait,
                                  boolean doPeek,
                                  int flags)
                           throws TPException

  Much like tpacall, this looks up the remote qspace as a service offered through the domain configuration file, and once it has located the proper remote domain through which to send the dequeue request, it sends it.

  Specified by:
    `tpdequeue` in interface `ApplicationToMonitorInterface`
  Parameters:
    `qspace` - same as ApplicationToMonitorInterface interface
    `qname` - same as ApplicationToMonitorInterface interface
    `msgid` - same as ApplicationToMonitorInterface interface
    `corrid` - same as ApplicationToMonitorInterface interface
    `doWait` - same as ApplicationToMonitorInterface interface
    `doPeek` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - tperrno is set to one of the following values. (Unless otherwise noted, failure does not affect the caller's transaction, if one exists.)
    - TPEINVAL Invalid arguments were given (for example, qname is null or flags are invalid).
    - TPENOENT Cannot access the qspace because it is not available (that is, the associated TMQUEUE(5) server is not available), or cannot start a global transaction due to the lack of entries in the Global Transaction Table (GTT).
    - TPEOTYPE The type and sub-type of the dequeued message are not known to the caller. When the call is made in transaction mode and this error occurs, the transaction is marked abort-only, and the message remains on the queue.
    - TPETIME A timeout occurred. If the caller is in transaction mode, a transaction timeout occurred and the transaction is to be aborted; otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified. If a transaction timeout occurred, any attempts to dequeue new messages will fail with TPETIME until the transaction has been aborted.
    - TPEBLOCK A blocking condition exists and TPNOBLOCK was specified.
    - TPEPROTO tpdequeue() was called improperly. There is no effect on the queue or the transaction.
    - TPESYSTEM A BEA Tuxedo system error has occurred. The exact nature of the error is written to a log file. There is no effect on the queue.
    - TPEOS An operating system error has occurred. There is no effect on the queue.
    - TPEDIAGNOSTIC The following diagnostic values may be returned in the exception:
      - QMEINVAL An invalid flag value was specified.
      - QMEBADRMID An invalid resource manager identifier was specified.
      - QMENOTOPEN The resource manager is not currently open.
      - QMETRAN The call was not in transaction mode or was made with the TPNOTRAN flag set and an error occurred trying to start a transaction in which to dequeue the message. This diagnostic is not returned by queue managers from BEA Tuxedo Release 7.1 or later.
      - QMEBADMSGID An invalid message identifier was specified for dequeuing.
      - QMESYSTEM A system error has occurred. The exact nature of the error is written to a log file.
      - QMEOS An operating system error has occurred.
      - QMEABORTED The operation was aborted. When executed within a global transaction, the global transaction has been marked rollback-only. Otherwise, the queue manager aborted the operation.
      - QMEPROTO A dequeue was done when the transaction state was not active.
      - QMEBADQUEUE An invalid or deleted queue name was specified.
      - QMENOMSG No message was available for dequeuing. Note that it is possible that the message exists on the queue and another application process has read the message from the queue. In this case, the message may be put back on the queue if that other process rolls back the transaction.
      - QMEINUSE When dequeuing a message by message identifier or correlation identifier, the specified message is in use by another transaction. Otherwise, all messages currently on the queue are in use by other transactions. This diagnostic is not returned by queue managers from BEA Tuxedo Release 7.1 or later.
      - QMESHARE When dequeuing a message from a specified queue, the specified queue is opened exclusively by another application. The other application is one based on a BEA product other than the BEA Tuxedo system that opened the queue for exclusive read and/or write using the Queuing Services API (QSAPI).
      - QMERELEASE An attempt was made to dequeue a message to a queue manager that is from a version of the BEA Tuxedo system that does not support a newer feature.

### tpdequeue

    public DequeueReply tpdequeue(String qspace,
                                  String qname,
                                  int flags)
                           throws TPException

  This is the simple version of tpdequeue, which is equalvalent to calling the other tpdequeue verb with null as the msgid and corrid and false as the values for doWait and doPeek.

  Specified by:
    `tpdequeue` in interface `ApplicationToMonitorInterface`
  Parameters:
    `qspace` - same as ApplicationToMonitorInterface interface
    `qname` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException`

### tpcall

    public Reply tpcall(String svc,
                        TypedBuffer data,
                        int flags)
                 throws TPException,
                        TPReplyException

  This implementation of tpcall looks up the proper service using the domain configuration files and/or MBeans. It then invokes the tpcall on the underlying atmi object returned.

  Specified by:
    `tpcall` in interface `ApplicationToMonitorInterface`
  Parameters:
    `svc` - same as ApplicationToMonitorInterface interface
    `data` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - Upon failure `tpcall` sets tperrno in TPException to one of the following values. Unless otherwise noted, failure does not affect the caller's transaction, if one exists.
    - TPEINVAL: Invalid arguments were given. For example: `svc` is null or flags are invalid.
    - TPENOENT: Cannot send to `svc` because it does not exist, it is a conversational service, or the name provided begins with "." - a dot.
    - TPEITYPE: The type and sub-type of data is not one of the allowed types and sub-types that `svc` accepts.
    - TPEOTYPE: The type and sub-type of the reply are not known to the caller. If the service request was made on behalf of the caller's current transaction, then the transaction is marked abort-only since the reply is discarded.
    - TPETRAN: `svc` belongs to a server that does not support transactions and TPNOTRAN was not set.
    - TPETIME: A timeout occurred. If the caller is in transaction mode, then a transaction timeout occurred and the transaction is marked abort-only. Otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified. If a transaction timeout occurred, then with one exception, any attempts to send new requests or receive outstanding replies fail with TPETIME until the transaction has been aborted. The exception is a request that does not block, expects no reply, and is not sent on behalf of the caller's transaction - that is, `tpacall` with TPNOTRAN, TPNOBLOCK, and TPNOREPLY set.
    - TPEBLOCK: A blocking condition was found on the send call and TPNOBLOCK was specified.
    - TPEPROTO: `tpcall` was called improperly.
    - TPESYSTEM: A BEA Tuxedo system error has occurred. The exact nature of the error is written to a log file.
    - TPEOS: An operating system error has occurred. If a message queue on a remote location is filled, TPEOS may be returned even if `tpcall` returned successfully.
    `TPReplyException` - If there was a service failure (TPESVCFAIL or TPSVCERROR), the exception will also have the reply data from the service.

### tpterm

    public void tpterm()

  This should be called by applications when they are finished with operations on this object. This is the equivalent of the JCA specified "close" operation, and will trigger the JCA cleanup and transactional cleanup operations to commence. No operations will be allowed on this object once this has been called.

  Specified by:
    `tpterm` in interface `ApplicationToMonitorInterface`

### tpconnect

    public Conversation tpconnect(String svc,
                                  TypedBuffer data,
                                  int flags)
                           throws TPException

  This implementation of tpconnect looks up the proper service using the domain configuration files and/or MBeans. It then invokes the conversation on the underlying atmi object returned.

  Specified by:
    `tpconnect` in interface `ApplicationToMonitorInterface`
  Parameters:
    `svc` - same as ApplicationToMonitorInterface interface
    `data` - same as ApplicationToMonitorInterface interface
    `flags` - same as ApplicationToMonitorInterface interface
  Returns:
    same as ApplicationToMonitorInterface interface
  Throws:
    `same` - as ApplicationToMonitorInterface interface
    `TPException` - Upon failure, t`tpconnect` returns a TPException exception to indicate the error condition. tperrno in TPException will be set to one of the following values:
    - TPEINVAL: Invalid arguments were given. For example, `svc` is null or flags are invalid.
    - TPETIME: A timeout occurred. If the caller is in transaction mode, then a transaction timeout occurred and the transaction is marked abort-only. Otherwise, a blocking timeout occurred and neither TPNOBLOCK nor TPNOTIME was specified. If a transaction timeout occurred, then with one exception, any attempts to send new requests or receive outstanding replies fail with TPETIME until the transaction has been aborted. The exception is a request that does not block, expects no reply, and is not sent on behalf of the caller's transaction - a `tpacall` with TPNOTRAN, TPNOBLOCK, and TPNOREPLY set.
    - TPEPROTO: `tpconnect` was called improperly.
    - TPESYSTEM: A BEA Tuxedo system error has occurred. The exact nature of the error is written to a log file.

### tpsprio

    public void tpsprio(int prio,
                        int flags)
                 throws TPException

  Sets the priority for the next request sent or forwarded by the current thread in the current context. The priority set affects only the next request sent. Priority can also be set for messages enqueued or dequeued by `tpenqueue` or `tpdequeue`. By default, the setting of `prio` increments or decrements a service's default priority up to a maximum of 100 or down to a minimum of 1, depending on its sign, where 100 is the highest priority. The default priority for a request is determined by the service to which the request is being sent. This default may be specified administratively (see UBBCONFIG(5)), or take the system default of 50. tpsprio() has no effect on messages sent via `tpconnect`or `tpsend`. A lower priority message does not remain enqueued forever because every tenth message is retrieved on a "first in, first out" (FIFO) basis. Response time should not be a concern of the lower priority interface or service. `flags` may be set to 0 or may be set to TPABSOLUTE. If TPABSOLUTE is set, then the priority of the next request should be sent out at the absolute value of prio. The absolute value of prio must be within the range 1 and 100, inclusive, with 100 being the highest priority. Any value outside of this range causes a default value to be used.

  ``
  Specified by:
    `tpsprio` in interface `ApplicationToMonitorInterface`
  Throws:
    `TPException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://edocs.bea.com/wls/docs103 Copyright 1996,2008, Oracle and/or its affiliates. All rights reserved. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD