tessl/maven-org-apache-activemq--artemis-commons

Common utilities, API classes, and shared functionality for Apache ActiveMQ Artemis message broker

—

Pending

Overview

Eval results

Files

Exception Handling

Name: tessl/maven-org-apache-activemq--artemis-commons
Author: tessl

Apache ActiveMQ Artemis Commons provides a comprehensive exception hierarchy with over 40 specific exception types, enabling precise error handling and diagnosis in message broker operations.

Base Exception Classes

ActiveMQException

The root exception class for all ActiveMQ Artemis API exceptions.

class ActiveMQException extends Exception {
    // Constructors
    ActiveMQException();
    ActiveMQException(String message);
    ActiveMQException(ActiveMQExceptionType type);
    ActiveMQException(ActiveMQExceptionType type, String message);
    ActiveMQException(String message, Throwable cause);
    ActiveMQException(ActiveMQExceptionType type, String message, Throwable cause);
    
    // Exception type access
    ActiveMQExceptionType getType();
}

Exception Type Enumeration

enum ActiveMQExceptionType {
    // Exception type constants for categorizing different error conditions
    // (Specific values depend on implementation)
}

Specific Exception Types

Address and Queue Exceptions

// Address does not exist
class ActiveMQAddressDoesNotExistException extends ActiveMQException {
    // Thrown when trying to access a non-existent address
}

// Address already exists
class ActiveMQAddressExistsException extends ActiveMQException {
    // Thrown when trying to create an address that already exists
}

// Address storage is full
class ActiveMQAddressFullException extends ActiveMQException {
    // Thrown when address cannot accept more messages due to storage limits
}

// Address deletion failed
class ActiveMQDeleteAddressException extends ActiveMQException {
    // Thrown when address deletion operation fails
}

// Queue does not exist
class ActiveMQNonExistentQueueException extends ActiveMQException {
    // Thrown when trying to access a non-existent queue
}

// Queue already exists
class ActiveMQQueueExistsException extends ActiveMQException {
    // Thrown when trying to create a queue that already exists
}

// Queue consumer limit reached
class ActiveMQQueueMaxConsumerLimitReached extends ActiveMQException {
    // Thrown when queue cannot accept more consumers
}

// Invalid queue configuration
class ActiveMQInvalidQueueConfiguration extends ActiveMQException {
    // Thrown when queue configuration is invalid
}

// Invalid transient queue usage
class ActiveMQInvalidTransientQueueUseException extends ActiveMQException {
    // Thrown when transient queue is used incorrectly
}

Connection and Session Exceptions

// Connection timed out
class ActiveMQConnectionTimedOutException extends ActiveMQException {
    // Thrown when connection establishment times out
}

// Client disconnected
class ActiveMQDisconnectedException extends ActiveMQException {
    // Thrown when client is unexpectedly disconnected
}

// Remote disconnect
class ActiveMQRemoteDisconnectException extends ActiveMQException {
    // Thrown when remote party initiates disconnection
}

// Not connected
class ActiveMQNotConnectedException extends ActiveMQException {
    // Thrown when operation requires connection but client is not connected
}

// Session creation failed
class ActiveMQSessionCreationException extends ActiveMQException {
    // Thrown when session cannot be created
}

// Incompatible client-server versions
class ActiveMQIncompatibleClientServerException extends ActiveMQException {
    // Thrown when client and server versions are incompatible
}

Transaction Exceptions

// Transaction outcome unknown
class ActiveMQTransactionOutcomeUnknownException extends ActiveMQException {
    // Thrown when transaction outcome cannot be determined
}

// Transaction rolled back
class ActiveMQTransactionRolledBackException extends ActiveMQException {
    // Thrown when transaction is rolled back
}

// Transaction timeout
class ActiveMQTransactionTimeoutException extends ActiveMQException {
    // Thrown when transaction exceeds timeout limit
}

Security Exceptions

// Security violation
class ActiveMQSecurityException extends ActiveMQException {
    // Thrown when security constraints are violated
}

// Cluster security violation
class ActiveMQClusterSecurityException extends ActiveMQException {
    // Thrown when cluster security is violated
}

I/O and System Exceptions

// I/O error
class ActiveMQIOErrorException extends ActiveMQException {
    // Thrown when I/O operations fail
}

// Native I/O error
class ActiveMQNativeIOError extends ActiveMQException {
    // Thrown when native I/O operations fail
}

// Internal error
class ActiveMQInternalErrorException extends ActiveMQException {
    // Thrown when internal system errors occur
}

// System shutdown
class ActiveMQShutdownException extends ActiveMQException {
    // Thrown when system is shutting down
}

// Object closed
class ActiveMQObjectClosedException extends ActiveMQException {
    // Thrown when trying to use a closed object
}

Message and Buffer Exceptions

// Large message error
class ActiveMQLargeMessageException extends ActiveMQException {
    // Thrown when large message processing fails
}

// Large message interrupted
class ActiveMQLargeMessageInterruptedException extends ActiveMQException {
    // Thrown when large message processing is interrupted
}

// Invalid buffer
class ActiveMQInvalidBufferException extends ActiveMQException {
    // Thrown when buffer is invalid or corrupted
}


// Unsupported packet
class ActiveMQUnsupportedPacketException extends ActiveMQException {
    // Thrown when packet type is not supported
}

// Interceptor rejected packet
class ActiveMQInterceptorRejectedPacketException extends ActiveMQException {
    // Thrown when message interceptor rejects packet
}

Routing and Filter Exceptions

// Routing error
class ActiveMQRoutingException extends ActiveMQException {
    // Thrown when message routing fails
}

// Unexpected routing type
class ActiveMQUnexpectedRoutingTypeForAddress extends ActiveMQException {
    // Thrown when routing type doesn't match address configuration
}

// Invalid filter expression
class ActiveMQInvalidFilterExpressionException extends ActiveMQException {
    // Thrown when message filter expression is invalid
}

// Divert does not exist
class ActiveMQDivertDoesNotExistException extends ActiveMQException {
    // Thrown when trying to access non-existent divert
}

Data and State Exceptions

// Duplicate ID violation
class ActiveMQDuplicateIdException extends ActiveMQException {
    // Thrown when duplicate ID is detected
}

// Duplicate metadata
class ActiveMQDuplicateMetaDataException extends ActiveMQException {
    // Thrown when duplicate metadata is encountered
}

// Illegal state
class ActiveMQIllegalStateException extends ActiveMQException {
    // Thrown when object is in illegal state for operation
}

// Null reference
class ActiveMQNullRefException extends ActiveMQException {
    // Thrown when null reference is encountered unexpectedly
}

// Property conversion error
class ActiveMQPropertyConversionException extends ActiveMQException {
    // Thrown when property type conversion fails
}

Threading and Interruption Exceptions

// Thread interruption
class ActiveMQInterruptedException extends ActiveMQException {
    // Thrown when thread is interrupted during operation
}

// Unblocked operation
class ActiveMQUnBlockedException extends ActiveMQException {
    // Thrown when blocking operation is unblocked
}

Replication and Timeout Exceptions

// Already replicating
class ActiveMQAlreadyReplicatingException extends ActiveMQException {
    // Thrown when replication is already in progress
}

// Replication timeout
class ActiveMQReplicationTimeooutException extends ActiveMQException {
    // Thrown when replication operation times out
}

// Operation timeout
class ActiveMQTimeoutException extends ActiveMQException {
    // Thrown when operation exceeds timeout limit
}

Exception Handling Patterns

Basic Exception Handling

import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.apache.activemq.artemis.api.core.ActiveMQExceptionType;

try {
    // ActiveMQ operations
    performArtemisOperation();
} catch (ActiveMQException e) {
    ActiveMQExceptionType type = e.getType();
    
    // Handle based on exception type
    switch (type) {
        case /* specific type */:
            // Handle specific error condition
            break;
        default:
            // Generic error handling
            logger.error("ActiveMQ operation failed", e);
    }
}

Specific Exception Handling

import org.apache.activemq.artemis.api.core.ActiveMQAddressFullException;
import org.apache.activemq.artemis.api.core.ActiveMQConnectionTimedOutException;
import org.apache.activemq.artemis.api.core.ActiveMQSecurityException;

try {
    // Queue or connection operations
    createQueueAndConnect();
} catch (ActiveMQAddressFullException e) {
    // Handle address full - maybe retry later or use different address
    handleAddressFull(e);
} catch (ActiveMQConnectionTimedOutException e) {
    // Handle connection timeout - retry with different parameters
    retryConnection(e);
} catch (ActiveMQSecurityException e) {
    // Handle security violation - check credentials or permissions
    handleSecurityError(e);
} catch (ActiveMQException e) {
    // Handle other ActiveMQ exceptions
    handleGenericActiveMQError(e);
}

Transaction Exception Handling

import org.apache.activemq.artemis.api.core.ActiveMQTransactionRolledBackException;
import org.apache.activemq.artemis.api.core.ActiveMQTransactionTimeoutException;

try {
    // Transaction operations
    performTransactionalWork();
    commitTransaction();
} catch (ActiveMQTransactionRolledBackException e) {
    // Transaction was rolled back - handle cleanup
    handleRollback(e);
} catch (ActiveMQTransactionTimeoutException e) {
    // Transaction timed out - may need to retry or extend timeout
    handleTransactionTimeout(e);
}

Resource Management with Exceptions

import org.apache.activemq.artemis.api.core.ActiveMQObjectClosedException;

try {
    // Use ActiveMQ resources
    useActiveMQResource(resource);
} catch (ActiveMQObjectClosedException e) {
    // Resource was closed - recreate or use alternative
    recreateResource();
} finally {
    // Always clean up resources
    if (resource != null) {
        try {
            resource.close();
        } catch (ActiveMQException e) {
            logger.warn("Error closing resource", e);
        }
    }
}

Exception Categories

Runtime vs Checked Exceptions

All ActiveMQ exceptions extend Exception (checked exception), requiring explicit handling or declaration in method signatures.

Recoverable vs Non-Recoverable

Recoverable: ActiveMQConnectionTimedOutException, ActiveMQAddressFullException - operations can be retried
Non-Recoverable: ActiveMQSecurityException, ActiveMQInternalErrorException - require configuration or system changes

Transient vs Persistent

Transient: ActiveMQTimeoutException, ActiveMQInterruptedException - may succeed on retry
Persistent: ActiveMQAddressDoesNotExistException, ActiveMQInvalidFilterExpressionException - require corrective action

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-activemq--artemis-commons

docs