fn init_cache_once()

in cachelib/rust/src/lrucache.rs [267:365]

• 90 lines of code
• 9 McCabe index (conditional complexity)

    fn init_cache_once(&mut self, _fb: FacebookInit, config: LruCacheConfig) -> Result<()> {
        let mut cache_config = ffi::make_lru_allocator_config()?;

        cache_config.pin_mut().setCacheSize(config.size);

        match config.shrinker {
            ShrinkerType::NoShrinker => {}
            ShrinkerType::Container => {
                if !ffi::enable_container_memory_monitor(cache_config.pin_mut())? {
                    return Err(ErrorKind::NotInContainer.into());
                }
            }
            ShrinkerType::Config(shrinker) => {
                let rebalancer = shrinker.strategy.get_strategy()?;
                match shrinker.shrinker_type {
                    ShrinkMonitorType::FreeMemory {
                        max_free_mem_gib,
                        min_free_mem_gib,
                    } => {
                        ffi::enable_free_memory_monitor(
                            cache_config.pin_mut(),
                            shrinker.interval.into(),
                            shrinker.max_resize_per_iteration_percent,
                            shrinker.max_removed_percent,
                            min_free_mem_gib,
                            max_free_mem_gib,
                            rebalancer,
                        )?;
                    }
                    ShrinkMonitorType::ResidentSize {
                        max_process_size_gib,
                        min_process_size_gib,
                    } => {
                        ffi::enable_resident_memory_monitor(
                            cache_config.pin_mut(),
                            shrinker.interval.into(),
                            shrinker.max_resize_per_iteration_percent,
                            shrinker.max_removed_percent,
                            min_process_size_gib,
                            max_process_size_gib,
                            rebalancer,
                        )?;
                    }
                }
            }
        };

        if let Some(pool_rebalance) = config.pool_rebalance {
            let rebalancer = pool_rebalance.strategy.get_strategy()?;
            ffi::enable_pool_rebalancing(
                cache_config.pin_mut(),
                rebalancer,
                pool_rebalance.interval.into(),
            )?;
        }
        if let Some(pool_resize) = config.pool_resize {
            let rebalancer = pool_resize.strategy.get_strategy()?;
            ffi::enable_pool_resizing(
                cache_config.pin_mut(),
                rebalancer,
                pool_resize.interval.into(),
                pool_resize.slabs_per_iteration,
            )?;
        }

        if let Some(AccessConfig {
            bucket_power,
            lock_power,
        }) = config.access_config
        {
            ffi::set_access_config(cache_config.pin_mut(), bucket_power, lock_power)?;
        }

        if let Some(cache_name) = config.cache_name {
            let_cxx_string!(name = cache_name);
            cache_config.pin_mut().setCacheName(&name);
        }

        if let Some(addr) = config.base_address {
            ffi::set_base_address(cache_config.pin_mut(), addr as usize)?;
        }

        if let Some(cache_directory) = config.cache_directory {
            // If cache directory is enabled, create a persistent shared-memory cache.
            let_cxx_string!(cache_directory = cache_directory.as_os_str().as_bytes());
            ffi::enable_cache_persistence(cache_config.pin_mut(), cache_directory);
            self.cache = ffi::make_shm_lru_allocator(cache_config)?;
        } else {
            let mut is_volatile = self.is_volatile.write().expect("lock poisoned");
            *is_volatile = true;
            self.cache = ffi::make_lru_allocator(cache_config)?;
        }

        if self.cache.is_null() {
            Err(ErrorKind::CacheNotInitialized.into())
        } else {
            Ok(())
        }
    }