iundarigun

local members = redis.call('smembers', KEYS[1])
for mem =1,#members do
    if redis.call('EXISTS', KEYS[2]..':'..members[mem]) ~= 1 then
        redis.call('SREM', KEYS[1], members[mem])
    end
end
return redis.call('smembers', KEYS[1])

iundarigun

    private val processingSomethingJobKey = "application:job:processingSomething"

    @Scheduled(cron = "0 0 0/1 1/1 * ?")
    fun processingSomething() {
       val canRun = redisTemplate.boundValueOps(processingSomethingJobKey)
           .setIfAbsent(UUID.randomUUID().toString(), 5L, TimeUnit.MINUTES)
        if (canRun != null && canRun) {
            log.info("Lock adquired. Running something in this instance")
        } else {
            log.info("Lock unavailable! Job is running in other instance")

iundarigun

    fun findByApplicationId(applicationId: String): Set<InstanceDefinition> {
        val instances = applicationRepository.findInstancesByApplicationId(applicationId)
        return instances.mapNotNull { instance ->
            getInstance(applicationId, instance)
        }.toSet()
    }

    private fun getInstance(applicationId: String, instance: String): InstanceDefinition? {
        val instanceDefinition = instanceRepository.getInstance(applicationId, instance)
        if (instanceDefinition == null) {

iundarigun

@Configuration
class RedisConfiguration {

    @Bean
    fun redisTemplate(
        connectionFactory: RedisConnectionFactory,
        objectMapper: ObjectMapper
    ): RedisTemplate<String, InstanceDefinition> {
        val template = RedisTemplate<String, InstanceDefinition>()

iundarigun

@Repository
class InstanceRepository(private val redisTemplate: RedisTemplate<String, InstanceDefinition>) {

    private val instancePrefixKey = "morethancache:instance"

    fun saveInstance(
        instanceDefinition: InstanceDefinition,
        instanceTtlInMinutes: Long
    ) {
        val key = "$instancePrefixKey:${instanceDefinition.application}:${instanceDefinition.uuid}"

iundarigun

package br.com.devcave.redis.repository

import org.springframework.data.redis.core.StringRedisTemplate
import org.springframework.stereotype.Repository

@Repository
class ApplicationRepository(private val redisTemplate: StringRedisTemplate) {

    private val applicationPrefixKey = "morethancache:application"

iundarigun

class CustomRedisCacheWriter(
    private val connectionFactory: RedisConnectionFactory,
    private val duration: Duration
) : RedisCacheWriter {

    private val log = LoggerFactory.getLogger(javaClass)

    // Other methods

    override fun get(name: String, key: ByteArray): ByteArray? {

iundarigun

        return RedisCacheManager.RedisCacheManagerBuilder.fromCacheWriter(lockingRedisCacheWriter)
//            .cacheDefaults(cache1MinuteConfiguration)  // Uncomment the line for default config
//            .disableCreateOnMissingCache()             // Uncomment the line for avoid unexpected caches
            .withCacheConfiguration("findAll", cache1MinuteConfiguration)
            .withCacheConfiguration("count", cache1MinuteConfiguration)
            .withCacheConfiguration("findById", cache60MinuteConfiguration)
            .build()
    }

iundarigun

@Configuration
class CacheConfiguration(
    private val connectionFactory: RedisConnectionFactory,
    private val objectMapper: ObjectMapper,
    @Value("\${spring.application.name}")
    private val applicationName: String
) {

    @Bean
    fun cacheManager(): CacheManager {

iundarigun

    @Cacheable("findById")
    fun findById(id: Long): Employee? {
          // some code
    }

    @Cacheable("findAll")
    fun findAll(): List<Employee> {
          // some code
    }