In this section, you will find the release notes for each version we release under this major version. If you are looking for the release notes of previous major versions, use the version switcher at the top left of this documentation book. Here is a breakdown of our major version releases.

Version 3.x

The 3.x series focuses on JDK11 minimal support and complete internal refactoring to leverage Gradle as a build system for all Java components. It also makes a major bump in all of our internal libraries.

Version 2.x

Version 2 is a major extension rewrite to support Redis Clusters and Redis Pub/Sub functionalities. It also included major updates to all the underlying Java architecture, Code Quality Metrics, Testing, and much more.

Version 1.a

The birth of Redis for Lucee

Ortus Redis Extension v3.x Docs

Requirements

• Lucee 5.1.0 and above

• Redis Standalone or Cluster 4.0.X and above

Commercial Product

Features In A Nutshell

• Add Redis native functionality to any Lucee server

• Install at server level (Available to all contexts)

• Create Cache connections in the Lucee web administrator or via Application.cfc to connect to any network-accessible Redis cluster

• Set and get objects from Redis via standard CFML functions and tags (cachePut(), cacheGet(), cfcache action="get|put")

• Fully supports all built-in Lucee cache functions including wildcard filters

• Seamlessly distribute storage of the following to any Redis Cluster

  • Lucee session storage

  • Lucee client storage

  • Lucee Ram resources (ram://...)

• Seamlessly cache the following to any timeout-sensitive Redis key

  • Results of database queries

  • Results of deterministic functions

  • Complex or simple objects in your application's code

  • Cached templates (cfcache action="content|cache|serverCache")

• Extremely lightweight and fast

• Ability to publish and subscribe to Redis channels for pub/sub capabilities: https://redis.io/topics/pubsub

• Native Redis functions:

  • RedisGetCluster( cacheName )

  • RedisGetClusterNodes( cacheName )

  • RedisGetConnectionPool( cacheName )

  • RedisGetProvider( cacheName )

  • RedisPublish( channel, message, cacheName )

  • RedisSubscribe( subscriber, channels, cacheName )

Support

The Ortus Redis Extension is a commercial product by Ortus Solutions. If you have purchased a license then you are entitled to customer support. You can either visit our support page to contact us or create an issue in our bug tracker.

New Feature

LRE-48 - Update Redis extension driver ( Jedis ) to v4.4.3 ( v3.0 ) and v4.4.6 ( v3.2.0 )

LRE-54 - Add settings for SSL transport and usernames to RedisClusterCache

LRE-55 - Add setting for username to RedisCache

LRE-58- Added redisLock tag for distributed locking ( v3.3.0 )

Additional Changes

Converted extension build process to use Gradle and compile against Lucee v5.4

New Feature

The source code for this book is hosted in GitHub:

• The majority of code examples in this book are done in cfscript.

External Trademarks & Copyrights

Redis is a copyright and trademark of Redis Labs, Inc.

Notice of Liability

The information in this book is distributed “as is”, without warranty. The author and Ortus Solutions, Corp shall not have any liability to any person or entity with respect to loss or damage caused or alleged to be caused directly or indirectly by the content of this training book, software and resources described in it.

Contributing

We highly encourage contribution to this book and our open source software. The source code for this book can be found in our GitHub repository where you can submit pull requests.

Charitable Proceeds

Shalom Children's Home

Shalom Children’s Home is one of the ministries that is dear to our hearts located in El Salvador. During the 12 year civil war that ended in 1990, many children were left orphaned or abandoned by parents who fled El Salvador. The Benners saw the need to help these children and received 13 children in 1982. Little by little, more children came on their own, churches and the government brought children to them for care, and the Shalom Children’s Home was founded.

Shalom now cares for over 80 children in El Salvador, from newborns to 18 years old. They receive shelter, clothing, food, medical care, education and life skills training in a Christian environment. The home is supported by a child sponsorship program.

We have personally supported Shalom for over 6 years now; it is a place of blessing for many children in El Salvador that either have no families or have been abandoned. This is good earth to seed and plant.

Version 2 is a major rewrite of our Java Extension. You can find the release notes and the major areas of improvement here.

Major Updates

Redis Logical Database Support

Now, you can add which logical database to connect to and partition your installation by logical database rather than by prefix. Thus, providing great separation of concerns for your connections and applications. On your cache connection details for the Redis Cache, just select which database number to connect to. That's it!

Redis Cluster Support

We have added the capability to connect to not only standalone Redis instances via our Redis Cache connector, but we have now introduced the Redis Cluster Cache connector. This connector can connect to any Redis Cluster and give you all the great features our extension gives.

Redis Cluster Functions

We have also introduced several new functions for usage in a cluster cache:

Redis Pub/Sub

We have introduced the capability for your CFML code to now leverage Redis Publish and Subscribe constructs. This will allow your CFML code to have native messaging via Redis.

What is Pub/Sub?

Redis Pub/Sub implements the Publish/Subscribe messaging paradigm. This decoupling of publishers and subscribers can allow for greater scalability and a more dynamic network topology.

1. Subscribers express interest in one or more channels (literal channels or pattern channels).

2. Publishers send messages into channels.

3. Redis will push these messages into different subscribers which have matched the channel's message.

Pub/Sub Functions

In order to leverage this pattern you will use the following two functions:

Publish Example

// Publish Example
<h2>Publishing messages...</h2>
<cfflush>
<cfscript>
	RedisPublish( "test-channel", "Hola mi amigo" );
	RedisPublish( "test-channel", "Hola mi amigo2" );
	RedisPublish( "test-channel", "Hola mi amigo Redis" );
</cfscript>
<h2>Finished publishing messages</h2>

Subscribe Example

<cfscript>
// Subscribe with closure
closureSubscriber = redisSubscribe( ( channel, message ) => {
	writeDump( var="Message received on channel #arguments.channel#, #arguments.message#", output="console" );
}, "test-channel" );

// Subscribe with CFC
cfcSubscriber = redisSubscribe( new Subscriber(), "test-channel" );

</cfscript>
<h1>Subscription started!! Check the logs!</h1>

Subscriber Listener CFC

component {

	public void function onMessage( String channel, String message ) {
		writeDump( var="Subscriber CFC -> onMessage called :#arguments.toString()#", output="console" );
	}

	public void function onPMessage( String pattern, String channel, String message ) {
		writeDump( var="Subscriber CFC -> onPMessage called :#arguments.toString()#", output="console" );
	}

	public void function onSubscribe( String channel, numeric subscribedChannels ) {
		writeDump( var="Subscriber CFC -> onSubscribe called :#arguments.toString()#", output="console" );
	}

	public void function onUnsubscribe( String channel, numeric subscribedChannels ) {
		writeDump( var="Subscriber CFC -> onUnsubscribe called :#arguments.toString()#", output="console" );
	}

	public void function onPUnsubscribe( String pattern, numeric subscribedChannels ) {
		writeDump( var="Subscriber CFC -> onPUnsubscribe called :#arguments.toString()#", output="console" );
	}

	public void function onPSubscribe( String pattern, numeric subscribedChannels ) {
		writeDump( var="Subscriber CFC -> onPSubscribe called :#arguments.toString()#", output="console" );
	}

}

Code Quality

Better Exception Handling

Dealing with exceptions is always nasty. However, in this release we have optimized all exceptions so better debugging is added and we can pinpoint bugs and improvements.

Release Notes

Fixed

Added

[2.2.1] => 2022-APR-06

Fixed

• Fixes an issue with property file license activation

[2.2.0] => 2022-MAR-31

Added

• Added support for cluster password authentication

• Added cluster cache configuration for read timeouts

• Added cluster cache configuration for max number of pool connections

[2.1.0] => 2022-MAR-16

Fixed

• Fixes an issue with Cluster cache connections due to uninstantiated connection manager

Added

• Added support for environmental configuration of license variables

  • REDIS_EXTENSION_EMAIL

  • REDIS_EXTENSION_LICENSE_KEY

  • REDIS_EXTENSION_SERVER_TYPE

  • REDIS_EXTENSION_ACTIVATION_CODE

• Added support for an array of hostnames and ports to the configuration ( e.g. hosts=redis1.myhost.com,redis2.myhost.com port=6379,6377 )

[2.0.0] => 2022-AUG-05

Fixed

Added

[1.4.0] => 2019-NOV-5

• New Features

  • Added a log4j bridge and custom appender so all log messages from the Redis library will not go out to the out logs in Lucee

• Improvements

  • Added all members of the RedisConnection class to be public/static so they can be inspected and reused

  • Added a getConnectionKeys() in the RedisConnection class to see which caches are configured and how

  • Added RuntTimeExceptions and IOExceptions whenever a Redis connection cannot be made to improve errors

  • Added more context when exceptions happen to the error messages

  • Converted all connection pool access to try's with resources for auto-closing and better code visibility

  • Coverted all valueList() and entryLIst() to leverage parallel streams for performance

• Bugs

  • Fixes an issue which caused the extension to fail on Lucee v5.2.9 and v5.3.x

[1.3.0] => 2019-SEP-30

• Added ability to set the following new settings on a cache connection:

  • Timeout

  • use SSL

  • Password

  • Max Connections

  • Max Idle Connections

[1.2.0] => 2019-MAR-05

• Auto publishing

• S3 Publishing automated

• Added more verbose logging

• Added more logging for exception handling

• Major fix for session expirations when using session clusters with Lucee

• Removed tests source from final package to reduce binary size

[1.1.0] => 2018-JAN-16

• Minor fixes on Logging

New Feature

Bug

Improvement

Task

There are a number of ways that the extension integrates Redis into your Lucee server. There is built-in caching, manual get/set of objects, and scope storage. Discover our sections from the left menu.

Lucee will allow you to seamlessly defer storage of your session and/or client scopes to Redis. You will set and access the scopes like you normally would in CFML, but behind the scenes Lucee stores a cache entry for each user containing their session/client variables in the Redis cluster.

This serves several purposes:

• Scopes are persisted across server restarts

• Lower memory usage since variables are NOT stored in the JVM's heap

• User sessions can be shared across web servers (No more sticky sessions)

• Redis cluster can be scaled out to handle whatever amount of users you need in a distributed fashion

This means you could take your single-server application with a heavy dependence on session/client variables, and scale it out to as many web servers as necessary behind a round-robin load balancer. Users are free to roam to any web server they want, and their session variables will follow them anywhere with no extra overhead. Perhaps you have millions of web site visitors and you're running out of heap space due to all the session storage. Push those sessions off to a distributed Redis layer that can scale out to meet demand, and that is no longer a bottleneck.

Storage Option

For both session and client storage, you will need to check the Storage box when creating or editing the cache connection you want to use in the Lucee admin. Remember you can create multiple buckets in Redis to help manage your documents and segregate RAM.

Set a cache as usable for session or client storage

Session

Once the cache is created, enabling session storage is easy. In your Application.cfc simply confirm sessionManagment is turned on and set the following two settings as well in the this scope:

• sessionType : This is the type of session to use, valid values are cfml and j2ee. Make sure that you select cfml or the extension will NOT work.

• sessionStorage : This is the name of the cache defined in your Lucee administrator that you wish to store sessions in

• sessionCluster : This controls how/when session data is sent and retrieved from the cache.

  • true: Session data is primarily stored in cache. It is always pulled from the cache at the start of each request, and backed up at the end. Use this setting if you have multiple applications using cached storage and you want the full benefit of distributed sessions.

  • false: Session data is primarily stored in memory but backed up on every request to the cache. Session data is only pulled from the cache if it doesn't exist in memory. Set this to false if you only have one application using session cache storage and you simply want to persist session storage across restarts.

Client

Storing your client scope in Redis is just as easy as session storage. In your Application.cfc confirm clientManagement is turned on and set the following two settings in the this scope:

• clientStorage: This is the name of the cache defined in your Lucee administrator that you wish to store client data in

• clientCluster: This controls how/when client data is sent and retrieved from the cache.

  • true: Client data is primarily stored in cache. It is always pulled from the cache at the start of each request, and backed up at the end. Use this setting if you have multiple applications using cached storage and you want the full benefit of distributed client data.

  • false: Client data is primarily stored in memory but backed up on every request to the cache. Client data is only pulled from the cache if it doesn't exist in memory. Set this to false if you only have one application using client cache storage and you simply want to persist client storage across restarts.

Redis Setup

Lucee Setup

The Redis extension is installed as a Lucee extension into any Lucee Server version 5.1.0 and above. The extension has to be installed at the server level context.

If installed in the server context, you can create server-level caches that are available to all web contexts in Lucee. The driver will also be available to all web contexts to add their own local caches or override caches if they need too as well.

ForgeBox Extension Provider

Installing the Extension

Now click Extensions > Applications and wait for the list to load. There should be an item in the list called Ortus Redis Cache. You can activate it as a trial or as a full version with a license key after you install.

Click it and then click the install button to begin the installation process.

Manual/Docker Installation

Lucee also allows you to deploy the extension file (.lex) into a special folder. Lucee will detect the extension and automatically install it for you. The location is the following

If anything goes wrong during the installation please verify the deploy logs in the following location

Activating the Extension

You will also have to determine the type of server you are installing the extension to. Development or non-public facing servers are FREE of charge and by default receive up to 4 activations.

Production servers get only 1 activation, so make sure you choose the correct server type. Once you get all your information in the form, click on the activate button to finalize the installation. Choose the trial option if you don't have a license and just want to try out the extension. When the trial expires, the cache provider will stop working! The trial is not for production use.

The Ortus Lucee Redis Extension should now be installed on your server and ready to use.

Downloading The Extension

If you will be using an offline installation or a Docker based installation, you can either follow the process above or download the extension and leverage a continuous integration server to build your images or server configurations. Please note that you will need a containerized server license to use this extension across multiple images.

From our artifact repository, download the appropriate lex file and drop it into your Lucee deploy folder: {lucee-server}/WEB-INF/lucee-server/deploy. Once the engine starts, it will deploy the extension for you automatically.

Automatic Activation

If you will be using Kubernetes, Docker Swarm or any other orchestrator, you will need to automate the process of activation. There are two methods of providing your activation information to the extension:

1. Activation via a properties file in the extension filesystem

2. Activation via environment variables

Since you will most likely want the server warmed up and ready to go, you may provide one of these two mechanisms in your build process. With environment variable-based activation, there is no need to hard-code the license information in to the container build, though you may do so. Simply supply these environment keys at runtime or via a .env file.

Environment Variable License Configuration

The environment variables used in activating the extension are:

• REDIS_EXTENSION_EMAIL - The email address used to purchase your extension

• REDIS_EXTENSION_LICENSE_KEY - The license key you were provided at registration

• REDIS_EXTENSION_SERVER_TYPE - Optional, defaults to Production

• REDIS_EXTENSION_ACTIVATION_CODE - The activation code for your extension and server type. Note that this can only be obtained manually through the Lucee admin, or by contacting our helpdesk.

Properties File License Configuration

To use the properties file method of license configuration, Create a license.properties file with the following content:

And place it in the following location: {lucee-server}/WEB-INF/lucee-server/context/context/ortus/redis/license.properties

Upon server startup, the file will be sourced in and the extension activated.

In clustered environments, it is often necessary to prevent multiple instances from executing methods at the same time, thus preventing collisions with data access and modificication. The <cfRedisLock> tag ( redisLock in script ) allows the user to place a lock across all running instances in the cluster.

The tag functions exactly like cflock/lock with the exception of the cache and bypass arguments. The the bypass argument can be useful in development environments when not using a distributed cache.

Tag Usage

Script Usage

The first and easiest way to use your new cache is via the built-in cache functions and tags in CFML. You can specify the cache name to use, but by default Lucee will use the cache you have designated as your default object cache.

Caching Objects

If you have selected your cache as the default Object cache in the admin, you can simply use functions like cachePut() and cacheGet(). Redis can handle arbitrary snippets of text (like HTML snippets) and even complex objects such as queries, arrays, or structs. The cache will automatically serialize the values and store them as text. They will be reconstituted when you retrieve them from the cache later.

Caching Function Output

Once you have selected a cache as the default function cache in the admin, you can use Redis to cache the results of oft-run functions. The cache key will be created for you automatically based on a hash of the method arguments thanks to Lucee. Cached functions should therefore be deterministic-- meaning the output of the function is purely a product of its parameters. Using function caching is easy, just add a cachedwithin attribute to the cffunction tag or function declaration.

This is what that function would look like in script

Caching Queries

Once you have selected a cache as the default query cache in the admin, you can use Redis to cache the results of oft-run database queries. The cache key will be created for you automatically based on a hash of the SQL statement and its parameters thanks to Lucee. Using query caching is as easy as function caching, just add a cachedwithin attribute to your query.

Per-application Cache Settings

You can specify what caches are the default storage mechanism for functions, queries, objects, etc in the Lucee server and web administrator. There is one more programmatic level this can be configured as well.

The following settings are available in your Application.cfc to override at an application level. Remember, the "object" cache is used by default if no cache name is specified to functions such as cachePut() and cacheGet().

You can also define an entire cache in your Application.cfc which makes your configuration completely portable.

Here's a general list of troubleshooting steps if you're getting errors. The log files are VERY important since the error Lucee throws doesn't always contain the information you need. You will have to crack open your Lucee logs to get the actual error out.

• Look in the "out" and "err" logs for information. These are usually found in the servlet container's log directory. For instance, if you're using Tomcat, look in Tomcat's log directory. There are often messages logged there that never make it up to the CFML engine.

• The Log4J output of the underlying Redis Java SDK will be redirected to your Lucee server's "Application" log. Adjusting the logging level for this log will affect how much information you get from Redis.

• Always scroll to the bottom of Java stack traces to look for a "caused by" section which is the original error.

• If you are getting connection errors or Null pointer exceptions, check the spelling of your hostnames and ports and make sure Redis is actually running with the bucket name you specified in the config.

• Once the library connects, you should see lines in the "out" log showing the servers being connected to successfully.

• Open up the Redis web admin on one of your nodes and watch the "Ops per second" graph while you hit your app. If you see spikes in the graph every time you hit the app, then it's working!

Once the extension is installed, you can begin to create cache connections and configure them either via the administrator, via the Application.cfc or via a CFConfig json file.

Admin Cache Connection

To add a new cache, click on Services > Cache and you should see a list of existing caches. If there are no existing caches, you should be taken straight to the create screen.

You have two cache options with our extension:

• Ortus Redis Cache : For standalone or connecting to a single Redis instance

• Ortus Redis Cluster Cache : For connecting to a Redis Cluster

You will then be taken to a page of options for each of the Redis Cache implementations.

RedisCache

The RedisCache is used for connecting to a single instance of Redis. That instance could be replicated, but that's another story. Let's check out the different options:

Storage

Check the Storage box if you want to be able to use this cache for session or client storage distribution.

Host

Enter the Redis server IP address or host name.

Port

The port of the Redis server.

Logical Database

The logical database to connect to in Redis. By default we connect to database 0.

Username

Password

The password of the Redis server, if any.

SSL

Enable SSL on the connection to the Redis Server.

Connection Timeout

The time in milliseconds to wait for a connection or throw an exception.

Socket Timeout

The cluster connection socket timeout in milliseconds

Pool Timeout

The the maximum amount of time, in milliseconds, to wait for a connection pool resource to become available

Max Connections

The maximum number of connections to allow to the Redis server.

Idle Connections

The maximum number of idle connections to keep in the pool to the Redis server

Cache Key Prefix

The default key prefix is lucee-cache. This will automatically prefix EVERY single cache item that goes into Redis. This will allow you to avoid collisions if you decide to register many Lucee caches or just to distinguish what comes from which cache connection.

Cache Key Case Sensitivity

By default all cache keys are transformed to lowercase to avoid any casing issues. However, if you want case sensitivity, then turn this option on.

Default

This is a Lucee feature where you can set the cache connection to be the default for all cache operations in Lucee (cacheGet(), cachePut(), etc). This can be one of the following or none at all.

RedisClusterCache

The RedisClusterCache is used for connecting to a cluster of Redis instances. This can be using Sentinel, or vanilla clustering or Redis Enterprise or Redis AWS/DigitalOcean. Let's check out the different options:

Storage

Check the Storage box if you want to be able to use this cache for session or client storage distribution.

Host(s)

Enter a comma-delimited list of all the IPs or hosts in the cluster. Not all are needed, but you should at least enter some to have redundancy.

Port

The port of the Redis cluster.

SSL

Whether SSL transport is enabled

Username

Password

The Redis cluster password

Connection Timeout

The time in milliseconds to wait for a connection or throw an exception.

Read Timeout

The timeout for a read of data from the cluster - defaults to the connection timeout

Socket Timeout

The cluster connection socket timeout in milliseconds

Pool Timeout

The the maximum amount of time, in milliseconds, to wait for a connection pool resource to become available

Max Connections

The maximum number of connections to the cluster allowed per pool - defaults to 50

Idle Timeout

The max idle time, in milliseconds, for a connection to remain in the pool.

Max Idle Connections

The maximum number of concurrently idle connections to retain in the pool

Max Attempts

The maximum number of connection attempts to make to the cluster.

Cache Key Prefix

The default key prefix is lucee-cache. This will automatically prefix EVERY single cache item that goes into Redis. This will allow you to avoid collisions if you decide to register many Lucee caches or just to distinguish what comes from which cache connection.

Cache Key Case Sensitivity

By default all cache keys are transformed to lowercase to avoid any casing issues. However, if you want case sensitivity, then turn this option on.

Default

This is a Lucee feature where you can set the cache connection to be the default for all cache operations in Lucee (cacheGet(), cachePut(), etc). This can be one of the following or none at all.

Application.cfc Connections

You can also add cache connections via your Application.cfc and avoid using the admin. Just open your Application.cfc and create a section under the pseudo-constructor (before the first function)

RedisCache

this.cache.connections["sessions"] = {
  class: 'ortus.extension.cache.redis.RedisCache', 
  storage: true, 
  custom: {
		"host":"127.0.0.1",
		"port":"6379"
		"username" : "",
		"password":"",
		"database" : "0",
		"useSSL": false,
		"timeout" : 2000,
		"socketTimeout" : 2000,
		"poolWaittimeout" : 1000,
		"maxConnections": 1000,
		"idleConnections": 10,
		"keyprefix":"lucee-cache",
		"cacheKeyCaseSensitivity" : false
	}, 
	default: 'object'
};

Please refer to the previous section to find out about what the custom options mean.

RedisClusterCache

this.cache.connections[ "myClusterCache" ] = {
  class: 'ortus.extension.cache.redis.RedisClusterCache', 
  storage: true, 
  custom: {
	"hosts":"127.0.0.1",
	"port":"7000",
	"username" : "",
	"password":"",
	"useSSL" : "",
	"timeout" : 2000,
	"readTimeout" : 2000,
	"socketTimeout" : 2000,
	"poolWaittimeout" : 1000,
	"maxAttempts" : 10,
	"maxConnections": 1000, 
	"maxIdleTime" : 30000,
	"maxIdleConnections" : 20, 
	"keyprefix":"lucee-cluster",			
	"cacheKeyCaseSensitivity" : false
}, 
default: 'object'
};

CFConfig Connections

You can also leverage a cfconfig.json file to store the cache configurations and automatically load them into your CFML server via CommandBox.

{
    "adminPassword" : "redis",
    "systemErr":"System",
    "systemOut":"System",
    "applicationTimeout":"1,0,0,0",
    "cacheDefaultObject":"sessions",
    "caches":{
        "sessions": {
            "class":"ortus.extension.cache.redis.RedisCache",
            "custom":{
                "cacheKeyCaseSensitivity":"false",
                "database" : "0",
                "idleConnections":"5",
                "maxConnections":"50",
		"username":"${REDIS_USERNAME}",
                "password":"${REDIS_PASSWORD}",
                "timeout":"2000",
                "useSSL":"false",
                "host":"${REDIS_HOST:127.0.0.1}",
                "keyprefix":"lucee-cache",
                "port":"${REDIS_PORT:6379}"
            },
            "readOnly":"false",
            "storage":"true"
        },
	"rediscluster": {
            "class":"ortus.extension.cache.redis.RedisClusterCache",
            "custom":{
                "hosts":"${REDIS_CLUSTER_HOSTS:127.0.0.1}",
                "keyprefix":"lucee-cluster",
                "username" : "${REDIS_CLUSTER_USERNAME}",
                "password" : "${REDIS_CLUSTER_PASSWORD}",
                "port":"${REDIS_CLUSTER_PORT:7000}",
		"useSSL" :"${REDIS_CLUSTER_USE_SSL:false}"
            },
            "readOnly":"false",
            "storage":"true"
        }
    },
    "inspectTemplate":"always",
    "requestTimeout":"0,0,0,50",
    "sessionMangement":"yes",
    "sessionTimeout":"0,0,30,0"
}

Please refer to the previous section to find out about what the custom options mean.

Once you setup Redis to be your default resource cache you can leverage it in many ways:

// Create a mapping to it
this.mappings[ "/cluster-fs" ] = "ram://";


// Do some file operations
fileWrite( "/cluster-fs/suzi.txt", myContent );
include template="/cluster-fs/aop.cfm";
directoryList( "/cluster-fs/caches" );

We have created several global CFML functions to interact with Redis

• redisGetProvider( [cachename=default] ) - Retrieves the underlying Ortus Cache implementation

• redisGetConnectionPool( [cachename=default] ) - Retrieves the Jedis pool for a specific connection cache

• redisGetCluster( [cachename=default] ) - Retrieves the Jedis cache cluster

• redisGetNodes( [cachename=default] ) - Retrieves a struct of the Jedis pool connections to the cluster.

RedisGetProvider()

RedisGetProvider() returns an instance to the Java class that Ortus wrote that proxies between the Redis client and Lucee. It implements lucee.commons.io.cache.Cache. For the most part you probably won't need this class, but there are a few methods in the Lucee cache interface that aren't available to you via CFML. You can also dump the class and check out all of its functions.

RedisGetConnectionPool()

What is Pub/Sub?

We have introduced the capability for your CFML code to now leverage Redis Publish and Subscribe constructs. This will allow your CFML code to have native messaging via Redis.

Redis Pub/Sub implements the Publish/Subscribe messaging paradigm. This decoupling of publishers and subscribers can allow for greater scalability and a more dynamic network topology.

1. Subscribers express interest in one or more channels (literal channels or pattern channels).

2. Publishers send messages into channels.

3. Redis will push these messages into different subscribers which have matched the channel's message.

Pub/Sub Functions

In order to leverage this pattern you will use the following two functions:

Publish Example

The return of the redisPublish() function is numeric indicating how many subscribers received the message.

Subscribe Example

The redisSubscribe() function returns a struct with two keys in it:

• future - A completable future that is running your subscriber.

• subscriber - The Java Redis subscriber object you can use to inspect the subscription or unsubscribe from the calls via the unsubscribe() method.

Subscriber Listener CFC

If you will be passing a CFC to the redisSubscribe() methods then you will need to implement some or all of the following functions.