WORKERS AHEAD!

You are viewing the development documentation for the Apereo CAS server. The functionality presented here is not officially released yet. This is a work in progress and will be continually updated as development moves forward. You are most encouraged to test the changes presented.

AMQP Ticket Registry

CAS can be enabled with a variety of messaging systems in order to distribute and share ticket data: from simplified use of the AMQP API to a complete infrastructure to receive messages asynchronously.

This registry is very much an extension of the default ticket registry. The difference is that ticket operations applied to the registry are broadcasted using a messaging queue to other listening CAS nodes on the queue. Each node keeps copies of ticket state on its own and only instructs others to keep their copy accurate by broadcasting messages and data associated with each. Each message and ticket registry instance running inside a CAS node in the cluster is tagged with a unique identifier in order to avoid endless looping behavior and recursive needless inbound operations.

The broadcast and the message queue is backed by the Advanced Message Queuing Protocol (AMQP) protocol. This is a platform-neutral, wire-level protocol for message-oriented middleware. The implementation of this protocol is backed by RabbitMQ. This is a lightweight, reliable, scalable, and portable message broker based on the AMQP protocol. CAS uses RabbitMQ to communicate through the AMQP protocol.

Support is enabled by including the following dependency in the overlay:

<dependency>
    <groupId>org.apereo.cas</groupId>
    <artifactId>cas-server-support-amqp-ticket-registry</artifactId>
    <version>${cas.version}</version>
</dependency>

implementation "org.apereo.cas:cas-server-support-amqp-ticket-registry:${project.'cas.version'}"

dependencyManagement {
    imports {
        mavenBom "org.apereo.cas:cas-server-support-bom:${project.'cas.version'}"
    }
}

dependencies {
    implementation "org.apereo.cas:cas-server-support-amqp-ticket-registry"
}

dependencies {
    /*
        The following platform references should be included automatically and are listed here for reference only.

        implementation enforcedPlatform("org.apereo.cas:cas-server-support-bom:${project.'cas.version'}")
        implementation platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES)
        
    */
    implementation "org.apereo.cas:cas-server-support-amqp-ticket-registry"
}

CAS Configuration

The following settings and properties are available from the CAS configuration catalog:

_{The configuration settings listed below are tagged as Required in the CAS configuration metadata. This flag indicates that the presence of the setting may be needed to activate or affect the behavior of the CAS feature and generally should be reviewed, possibly owned and adjusted. If the setting is assigned a default value, you do not need to strictly put the setting in your copy of the configuration, but should review it nonetheless to make sure it matches your deployment expectations.}

cas.ticket.registry.in-memory.crypto.encryption.key=

The encryption key. The encryption key by default and unless specified otherwise must be randomly-generated string whose length is defined by the encryption key size setting.

org.apereo.cas.configuration.model.core.util.EncryptionRandomizedCryptoProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

When possible, properties should be stored in lower-case kebab format, such as cas.property-name=value. The only possible exception to this rule is when naming actuator endpoints; The name of the actuator endpoints (i.e. ssoSessions) MUST remain in camelCase mode.

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.encryption.key=...

This is the most common form of property configuration that is recognized by CAS, regardless of the actual property source, which might in fact be managed separately outside the CAS environment, by another system or cloud framework.

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          encryption: 
            key: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.encryption.key="..." -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory. Note the placement of the system property which must be specified before the CAS web application is launched.

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_ENCRYPTION_KEY="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.encryption.key="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.signing.key=

The signing key is a JWT whose length is defined by the signing key size setting.

This setting supports the Spring Expression Language.

org.apereo.cas.configuration.model.core.util.SigningJwtCryptoProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.signing.key=...

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          signing: 
            key: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.signing.key="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_SIGNING_KEY="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.signing.key="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

_{The configuration settings listed below are tagged as Optional in the CAS configuration metadata. This
flag indicates that the presence of the setting
is not immediately necessary in the end-user CAS configuration, because a default value is assigned or
the activation of the feature is not conditionally controlled by the setting value. In other words, you should only include this field in your
configuration if you need to modify the default value or if you need to turn on the feature controlled by the setting.}

cas.ticket.registry.in-memory.concurrency=20

The estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads.

org.apereo.cas.configuration.model.core.ticket.registry.InMemoryTicketRegistryProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.concurrency=20

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        concurrency: "20"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.concurrency="20" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CONCURRENCY="20"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.concurrency="20"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.initial-capacity=1000

The initial capacity of the underlying memory store. The implementation performs internal sizing to accommodate this many elements.

org.apereo.cas.configuration.model.core.ticket.registry.InMemoryTicketRegistryProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.initial-capacity=1000

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        initial-capacity: "1000"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.initial-capacity="1000" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_INITIAL_CAPACITY="1000"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.initial-capacity="1000"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.load-factor=1

The load factor threshold, used to control resizing. Resizing may be performed when the average number of elements per bin exceeds this threshold.

org.apereo.cas.configuration.model.core.ticket.registry.InMemoryTicketRegistryProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.load-factor=1

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        load-factor: "1"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.load-factor="1" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_LOAD_FACTOR="1"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.load-factor="1"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.alg=AES

The signing/encryption algorithm to use.

org.apereo.cas.configuration.model.core.util.EncryptionRandomizedSigningJwtCryptographyProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.alg=AES

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          alg: "AES"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.alg="AES" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_ALG="AES"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.alg="AES"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.enabled=true

Whether crypto operations are enabled.

org.apereo.cas.configuration.model.core.util.EncryptionRandomizedSigningJwtCryptographyProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.enabled=true

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          enabled: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.enabled="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_ENABLED="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.enabled="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.encryption.key-size=16

Encryption key size.

org.apereo.cas.configuration.model.core.util.EncryptionRandomizedCryptoProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.encryption.key-size=16

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          encryption: 
            key-size: "16"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.encryption.key-size="16" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_ENCRYPTION_KEY_SIZE="16"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.encryption.key-size="16"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.signing-enabled=true

Whether signing encryption operations are enabled.

org.apereo.cas.configuration.model.core.util.EncryptionRandomizedSigningJwtCryptographyProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.signing-enabled=true

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          signing-enabled: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.signing-enabled="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_SIGNING_ENABLED="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.signing-enabled="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

cas.ticket.registry.in-memory.crypto.signing.key-size=512

The signing key size.

org.apereo.cas.configuration.model.core.util.SigningJwtCryptoProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

cas.ticket.registry.in-memory.crypto.signing.key-size=512

CAS properties can be specified using the YAML syntax:

cas: 
  ticket: 
    registry: 
      in-memory: 
        crypto: 
          signing: 
            key-size: "512"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dcas.ticket.registry.in-memory.crypto.signing.key-size="512" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export CAS_TICKET_REGISTRY_IN_MEMORY_CRYPTO_SIGNING_KEY_SIZE="512"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --cas.ticket.registry.in-memory.crypto.signing.key-size="512"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

_{The configuration settings listed below are tagged as Third Party in the CAS configuration metadata. This flag indicates that the configuration setting is not controlled, owned or managed by the CAS ecosystem, and affects functionality that is offered by a third-party library, such as Spring Boot or Spring Cloud to CAS. For additional info, you might have to visit the third-party source to find more details.}

spring.rabbitmq.address-shuffle-mode=none

Mode used to shuffle configured addresses.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.address-shuffle-mode=none

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    address-shuffle-mode: "none"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.address-shuffle-mode="none" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_ADDRESS_SHUFFLE_MODE="none"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.address-shuffle-mode="none"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.addresses=

Comma-separated list of addresses to which the client should connect. When set, the host and port are ignored.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.addresses=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    addresses: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.addresses="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_ADDRESSES="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.addresses="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.cache.channel.checkout-timeout=

Duration to wait to obtain a channel if the cache size has been reached. If 0, always create a new channel.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Cache$Channel.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.cache.channel.checkout-timeout=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    cache: 
      channel: 
        checkout-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.cache.channel.checkout-timeout="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CACHE_CHANNEL_CHECKOUT_TIMEOUT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.cache.channel.checkout-timeout="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.cache.channel.size=

Number of channels to retain in the cache. When "check-timeout" > 0, max channels per connection.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Cache$Channel.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.cache.channel.size=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    cache: 
      channel: 
        size: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.cache.channel.size="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CACHE_CHANNEL_SIZE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.cache.channel.size="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.cache.connection.mode=channel

Connection factory cache mode.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Cache$Connection.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.cache.connection.mode=channel

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    cache: 
      connection: 
        mode: "channel"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.cache.connection.mode="channel" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CACHE_CONNECTION_MODE="channel"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.cache.connection.mode="channel"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.cache.connection.size=

Number of connections to cache. Only applies when mode is CONNECTION.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Cache$Connection.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.cache.connection.size=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    cache: 
      connection: 
        size: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.cache.connection.size="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CACHE_CONNECTION_SIZE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.cache.connection.size="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.channel-rpc-timeout=10m

Continuation timeout for RPC calls in channels. Set it to zero to wait forever.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.channel-rpc-timeout=10m

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    channel-rpc-timeout: "10m"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.channel-rpc-timeout="10m" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CHANNEL_RPC_TIMEOUT="10m"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.channel-rpc-timeout="10m"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.connection-timeout=

Connection timeout. Set it to zero to wait forever.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.connection-timeout=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    connection-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.connection-timeout="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_CONNECTION_TIMEOUT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.connection-timeout="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.dynamic=true

Whether to create an AmqpAdmin bean.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.dynamic=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    dynamic: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.dynamic="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_DYNAMIC="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.dynamic="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.host=localhost

RabbitMQ host. Ignored if an address is set.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.host=localhost

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    host: "localhost"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.host="localhost" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_HOST="localhost"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.host="localhost"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.acknowledge-mode=

Acknowledge mode of container.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.acknowledge-mode=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        acknowledge-mode: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.acknowledge-mode="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_ACKNOWLEDGE_MODE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.acknowledge-mode="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.auto-startup=true

Whether to start the container automatically on startup.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.auto-startup=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        auto-startup: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.auto-startup="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_AUTO_STARTUP="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.auto-startup="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.consumers-per-queue=

Number of consumers per queue.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.consumers-per-queue=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        consumers-per-queue: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.consumers-per-queue="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_CONSUMERS_PER_QUEUE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.consumers-per-queue="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.de-batching-enabled=true

Whether the container should present batched messages as discrete messages or call the listener with the batch.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.de-batching-enabled=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        de-batching-enabled: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.de-batching-enabled="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_DE_BATCHING_ENABLED="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.de-batching-enabled="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.default-requeue-rejected=

Whether rejected deliveries are re-queued by default.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.default-requeue-rejected=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        default-requeue-rejected: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.default-requeue-rejected="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_DEFAULT_REQUEUE_REJECTED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.default-requeue-rejected="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.force-stop=false

Whether the container (when stopped) should stop immediately after processing the current message or stop after processing all pre-fetched messages.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.force-stop=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        force-stop: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.force-stop="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_FORCE_STOP="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.force-stop="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.idle-event-interval=

How often idle container events should be published.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.idle-event-interval=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        idle-event-interval: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.idle-event-interval="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_IDLE_EVENT_INTERVAL="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.idle-event-interval="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.missing-queues-fatal=false

Whether to fail if the queues declared by the container are not available on the broker.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.missing-queues-fatal=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        missing-queues-fatal: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.missing-queues-fatal="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_MISSING_QUEUES_FATAL="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.missing-queues-fatal="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.observation-enabled=false

Whether to enable observation.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.observation-enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        observation-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.observation-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_OBSERVATION_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.observation-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.prefetch=

Maximum number of unacknowledged messages that can be outstanding at each consumer.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$DirectContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.prefetch=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        prefetch: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.prefetch="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_PREFETCH="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.prefetch="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.enabled=false

Whether publishing retries are enabled.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.initial-interval=1000ms

Duration between the first and second attempt to deliver a message.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.initial-interval=1000ms

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          initial-interval: "1000ms"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.initial-interval="1000ms" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_INITIAL_INTERVAL="1000ms"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.initial-interval="1000ms"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.max-attempts=3

Maximum number of attempts to deliver a message.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.max-attempts=3

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          max-attempts: "3"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.max-attempts="3" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_MAX_ATTEMPTS="3"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.max-attempts="3"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.max-interval=10000ms

Maximum duration between attempts.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.max-interval=10000ms

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          max-interval: "10000ms"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.max-interval="10000ms" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_MAX_INTERVAL="10000ms"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.max-interval="10000ms"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.multiplier=1

Multiplier to apply to the previous retry interval.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.multiplier=1

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          multiplier: "1"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.multiplier="1" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_MULTIPLIER="1"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.multiplier="1"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.direct.retry.stateless=true

Whether retries are stateless or stateful.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.direct.retry.stateless=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      direct: 
        retry: 
          stateless: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.direct.retry.stateless="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_DIRECT_RETRY_STATELESS="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.direct.retry.stateless="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.acknowledge-mode=

Acknowledge mode of container.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.acknowledge-mode=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        acknowledge-mode: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.acknowledge-mode="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_ACKNOWLEDGE_MODE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.acknowledge-mode="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.auto-startup=true

Whether to start the container automatically on startup.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.auto-startup=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        auto-startup: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.auto-startup="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_AUTO_STARTUP="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.auto-startup="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.batch-size=

Batch size, expressed as the number of physical messages, to be used by the container.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.batch-size=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        batch-size: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.batch-size="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_BATCH_SIZE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.batch-size="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.concurrency=

Minimum number of listener invoker threads.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.concurrency=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        concurrency: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.concurrency="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_CONCURRENCY="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.concurrency="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.consumer-batch-enabled=false

Whether the container creates a batch of messages based on the 'receive-timeout' and 'batch-size'. Coerces 'de-batching-enabled' to true to include the contents of a producer created batch in the batch as discrete records.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.consumer-batch-enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        consumer-batch-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.consumer-batch-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_CONSUMER_BATCH_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.consumer-batch-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.de-batching-enabled=true

Whether the container should present batched messages as discrete messages or call the listener with the batch.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.de-batching-enabled=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        de-batching-enabled: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.de-batching-enabled="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_DE_BATCHING_ENABLED="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.de-batching-enabled="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.default-requeue-rejected=

Whether rejected deliveries are re-queued by default.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.default-requeue-rejected=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        default-requeue-rejected: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.default-requeue-rejected="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_DEFAULT_REQUEUE_REJECTED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.default-requeue-rejected="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.force-stop=false

Whether the container (when stopped) should stop immediately after processing the current message or stop after processing all pre-fetched messages.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.force-stop=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        force-stop: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.force-stop="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_FORCE_STOP="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.force-stop="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.idle-event-interval=

How often idle container events should be published.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.idle-event-interval=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        idle-event-interval: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.idle-event-interval="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_IDLE_EVENT_INTERVAL="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.idle-event-interval="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.max-concurrency=

Maximum number of listener invoker threads.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.max-concurrency=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        max-concurrency: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.max-concurrency="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_MAX_CONCURRENCY="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.max-concurrency="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.missing-queues-fatal=true

Whether to fail if the queues declared by the container are not available on the broker and/or whether to stop the container if one or more queues are deleted at runtime.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.missing-queues-fatal=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        missing-queues-fatal: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.missing-queues-fatal="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_MISSING_QUEUES_FATAL="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.missing-queues-fatal="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.observation-enabled=false

Whether to enable observation.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.observation-enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        observation-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.observation-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_OBSERVATION_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.observation-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.prefetch=

Maximum number of unacknowledged messages that can be outstanding at each consumer.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$SimpleContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.prefetch=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        prefetch: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.prefetch="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_PREFETCH="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.prefetch="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.enabled=false

Whether publishing retries are enabled.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.initial-interval=1000ms

Duration between the first and second attempt to deliver a message.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.initial-interval=1000ms

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          initial-interval: "1000ms"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.initial-interval="1000ms" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_INITIAL_INTERVAL="1000ms"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.initial-interval="1000ms"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.max-attempts=3

Maximum number of attempts to deliver a message.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.max-attempts=3

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          max-attempts: "3"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.max-attempts="3" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_MAX_ATTEMPTS="3"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.max-attempts="3"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.max-interval=10000ms

Maximum duration between attempts.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.max-interval=10000ms

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          max-interval: "10000ms"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.max-interval="10000ms" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_MAX_INTERVAL="10000ms"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.max-interval="10000ms"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.multiplier=1

Multiplier to apply to the previous retry interval.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.multiplier=1

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          multiplier: "1"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.multiplier="1" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_MULTIPLIER="1"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.multiplier="1"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.retry.stateless=true

Whether retries are stateless or stateful.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$ListenerRetry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.retry.stateless=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        retry: 
          stateless: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.retry.stateless="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_RETRY_STATELESS="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.retry.stateless="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.simple.transaction-size=

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.simple.transaction-size=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      simple: 
        transaction-size: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.simple.transaction-size="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_SIMPLE_TRANSACTION_SIZE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.simple.transaction-size="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

Deprecation status is ERRORwithout a replacement setting.

spring.rabbitmq.listener.stream.native-listener=false

Whether the container will support listeners that consume native stream messages instead of Spring AMQP messages.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$StreamContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.stream.native-listener=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      stream: 
        native-listener: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.stream.native-listener="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_STREAM_NATIVE_LISTENER="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.stream.native-listener="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.stream.observation-enabled=false

Whether to enable observation.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$StreamContainer.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.stream.observation-enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      stream: 
        observation-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.stream.observation-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_STREAM_OBSERVATION_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.stream.observation-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.listener.type=simple

Listener container type.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Listener.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.listener.type=simple

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    listener: 
      type: "simple"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.listener.type="simple" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_LISTENER_TYPE="simple"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.listener.type="simple"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.max-inbound-message-body-size=64MB

Maximum size of the body of inbound (received) messages.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.max-inbound-message-body-size=64MB

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    max-inbound-message-body-size: "64MB"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.max-inbound-message-body-size="64MB" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_MAX_INBOUND_MESSAGE_BODY_SIZE="64MB"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.max-inbound-message-body-size="64MB"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.password=guest

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.password=guest

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    password: "guest"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.password="guest" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_PASSWORD="guest"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.password="guest"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.port=

RabbitMQ port. Ignored if an address is set. Default to 5672, or 5671 if SSL is enabled.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.port=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    port: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.port="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_PORT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.port="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.publisher-confirm-type=

Type of publisher confirms to use.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.publisher-confirm-type=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    publisher-confirm-type: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.publisher-confirm-type="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_PUBLISHER_CONFIRM_TYPE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.publisher-confirm-type="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.publisher-confirms=

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.publisher-confirms=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    publisher-confirms: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.publisher-confirms="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_PUBLISHER_CONFIRMS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.publisher-confirms="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

Deprecation status is ERRORwithout a replacement setting.

spring.rabbitmq.publisher-returns=false

Whether to enable publisher returns.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.publisher-returns=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    publisher-returns: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.publisher-returns="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_PUBLISHER_RETURNS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.publisher-returns="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.requested-channel-max=2047

Number of channels per connection requested by the client. Use 0 for unlimited.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.requested-channel-max=2047

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    requested-channel-max: "2047"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.requested-channel-max="2047" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_REQUESTED_CHANNEL_MAX="2047"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.requested-channel-max="2047"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.requested-heartbeat=

Requested heartbeat timeout; zero for none. If a duration suffix is not specified, seconds will be used.

org.springframework.boot.autoconfigure.amqp.RabbitProperties.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.requested-heartbeat=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    requested-heartbeat: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.requested-heartbeat="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_REQUESTED_HEARTBEAT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.requested-heartbeat="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.algorithm=

SSL algorithm to use. By default, configured by the Rabbit client library.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.algorithm=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      algorithm: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.algorithm="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_ALGORITHM="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.algorithm="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.bundle=

SSL bundle name.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.bundle=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      bundle: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.bundle="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_BUNDLE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.bundle="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.enabled=

Whether to enable SSL support. Determined automatically if an address is provided with the protocol (amqp:// vs. amqps://).

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.key-store=

Path to the key store that holds the SSL certificate.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.key-store=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      key-store: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.key-store="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_KEY_STORE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.key-store="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.key-store-algorithm=SunX509

Key store algorithm.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.key-store-algorithm=SunX509

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      key-store-algorithm: "SunX509"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.key-store-algorithm="SunX509" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_KEY_STORE_ALGORITHM="SunX509"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.key-store-algorithm="SunX509"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.key-store-password=

Password used to access the key store.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.key-store-password=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      key-store-password: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.key-store-password="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_KEY_STORE_PASSWORD="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.key-store-password="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.key-store-type=PKCS12

Key store type.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.key-store-type=PKCS12

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      key-store-type: "PKCS12"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.key-store-type="PKCS12" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_KEY_STORE_TYPE="PKCS12"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.key-store-type="PKCS12"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.trust-store=

Trust store that holds SSL certificates.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.trust-store=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      trust-store: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.trust-store="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_TRUST_STORE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.trust-store="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.trust-store-algorithm=SunX509

Trust store algorithm.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.trust-store-algorithm=SunX509

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      trust-store-algorithm: "SunX509"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.trust-store-algorithm="SunX509" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_TRUST_STORE_ALGORITHM="SunX509"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.trust-store-algorithm="SunX509"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.trust-store-password=

Password used to access the trust store.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.trust-store-password=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      trust-store-password: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.trust-store-password="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_TRUST_STORE_PASSWORD="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.trust-store-password="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.trust-store-type=JKS

Trust store type.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.trust-store-type=JKS

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      trust-store-type: "JKS"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.trust-store-type="JKS" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_TRUST_STORE_TYPE="JKS"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.trust-store-type="JKS"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.validate-server-certificate=true

Whether to enable server side certificate validation.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.validate-server-certificate=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      validate-server-certificate: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.validate-server-certificate="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_VALIDATE_SERVER_CERTIFICATE="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.validate-server-certificate="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.ssl.verify-hostname=true

Whether to enable hostname verification.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Ssl.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.ssl.verify-hostname=true

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    ssl: 
      verify-hostname: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.ssl.verify-hostname="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_SSL_VERIFY_HOSTNAME="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.ssl.verify-hostname="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.host=localhost

Host of a RabbitMQ instance with the Stream plugin enabled.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.host=localhost

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      host: "localhost"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.host="localhost" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_HOST="localhost"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.host="localhost"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.name=

Name of the stream.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.name=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      name: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.name="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_NAME="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.name="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.password=

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.password=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      password: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.password="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_PASSWORD="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.password="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.port=

Stream port of a RabbitMQ instance with the Stream plugin enabled.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.port=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      port: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.port="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_PORT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.port="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.username=

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.username=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      username: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.username="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_USERNAME="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.username="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.stream.virtual-host=

Virtual host of a RabbitMQ instance with the Stream plugin enabled. When not set, spring.rabbitmq.virtual-host is used.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Stream.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.stream.virtual-host=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    stream: 
      virtual-host: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.stream.virtual-host="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_STREAM_VIRTUAL_HOST="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.stream.virtual-host="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.allowed-list-patterns=

Simple patterns for allowable packages/classes for deserialization.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.allowed-list-patterns=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      allowed-list-patterns: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.allowed-list-patterns="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_ALLOWED_LIST_PATTERNS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.allowed-list-patterns="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.default-receive-queue=

Name of the default queue to receive messages from when none is specified explicitly.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.default-receive-queue=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      default-receive-queue: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.default-receive-queue="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_DEFAULT_RECEIVE_QUEUE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.default-receive-queue="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.exchange=

Name of the default exchange to use for send operations.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.exchange=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      exchange: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.exchange="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_EXCHANGE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.exchange="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.mandatory=

Whether to enable mandatory messages.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.mandatory=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      mandatory: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.mandatory="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_MANDATORY="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.mandatory="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.observation-enabled=false

Whether to enable observation.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.observation-enabled=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      observation-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.observation-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_OBSERVATION_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.observation-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.queue=

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.queue=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      queue: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.queue="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_QUEUE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.queue="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

Deprecation status is ERRORwith a replacement setting: spring.rabbitmq.template.default-receive-queue.

spring.rabbitmq.template.receive-timeout=

Timeout for receive() operations.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.receive-timeout=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      receive-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.receive-timeout="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SPRING_RABBITMQ_TEMPLATE_RECEIVE_TIMEOUT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --spring.rabbitmq.template.receive-timeout="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

spring.rabbitmq.template.reply-timeout=

Timeout for sendAndReceive() operations.

org.springframework.boot.autoconfigure.amqp.RabbitProperties$Template.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

spring.rabbitmq.template.reply-timeout=...

CAS properties can be specified using the YAML syntax:

spring: 
  rabbitmq: 
    template: 
      reply-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dspring.rabbitmq.template.reply-timeout="..." -jar build/libs/cas.war