All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.neo4j.configuration.DatabaseConfig Maven / Gradle / Ivy

Go to download

Code responsible for parsing the Neo4j configuration.

There is a newer version: 5.23.0
Show newest version
/*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [http://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
package org.neo4j.configuration;

import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.neo4j.graphdb.config.Setting;
import org.neo4j.kernel.database.NamedDatabaseId;
import org.neo4j.kernel.lifecycle.Lifecycle;
import org.neo4j.logging.Log;

import static java.lang.Boolean.TRUE;
import static org.neo4j.configuration.GraphDatabaseSettings.allow_upgrade;
import static org.neo4j.configuration.GraphDatabaseSettings.record_format;

public class DatabaseConfig extends Config implements Lifecycle
{
    private final Map,Object> databaseSpecificSettings;
    private final Config globalConfig;
    private final Map, Object> overriddenSettings;
    private Map,Collection>> registeredListeners = new ConcurrentHashMap<>();

    public DatabaseConfig( Map,Object> databaseSpecificSettings, Config globalConfig, NamedDatabaseId namedDatabaseId )
    {
        this.databaseSpecificSettings = databaseSpecificSettings;
        this.globalConfig = globalConfig;
        overriddenSettings = !namedDatabaseId.isSystemDatabase() ? null : Map.of(
                record_format, "", //Latest version of the format family it is currently on. Needs to work in rolling upgrade.
                allow_upgrade, TRUE
        );
    }

    @Override
    public  T get( Setting setting )
    {
        if ( overriddenSettings != null )
        {
            Object o = overriddenSettings.get( setting );
            if ( o != null )
            {
                //noinspection unchecked
                return (T) o;
            }
        }
        Object dbSpecific = databaseSpecificSettings.get( setting );
        if ( dbSpecific != null )
        {
            return (T) dbSpecific;
        }
        return globalConfig.get( setting );
    }

    @Override
    public  void addListener( Setting setting, SettingChangeListener listener )
    {
        registeredListeners.computeIfAbsent( (SettingImpl) setting, v -> new ConcurrentLinkedQueue<>() ).add(
                (SettingChangeListener) listener );
        globalConfig.addListener( setting, listener );
    }

    @Override
    public  void removeListener( Setting setting, SettingChangeListener listener )
    {
        Collection> listeners = registeredListeners.get( setting );
        if ( listeners != null )
        {
            listeners.remove( listener );
        }
        globalConfig.removeListener( setting, listener );
    }

    @Override
    public void setLogger( Log internalLog )
    {
        globalConfig.setLogger( internalLog );
    }

    @Override
    public  Map getGroups( Class group )
    {
        return globalConfig.getGroups( group );
    }

    @Override
    public  Map,Map> getGroupsFromInheritance( Class parentClass )
    {
        return globalConfig.getGroupsFromInheritance( parentClass );
    }

    @Override
    public  SettingObserver getObserver( Setting setting )
    {
        return globalConfig.getObserver( setting );
    }

    @Override
    public  void setDynamic( Setting setting, T value, String scope )
    {
        globalConfig.setDynamic( setting, value, scope );
    }

    @Override
    public  void set( Setting setting, T value )
    {
        globalConfig.set( setting, value );
    }

    @Override
    public  void setIfNotSet( Setting setting, T value )
    {
        globalConfig.setIfNotSet( setting, value );
    }

    @Override
    public boolean isExplicitlySet( Setting setting )
    {
        return globalConfig.isExplicitlySet( setting );
    }

    @Override
    public String toString()
    {
        return globalConfig.toString();
    }

    @Override
    public Map,Object> getValues()
    {
        return globalConfig.getValues();
    }

    @Override
    public Map> getDeclaredSettings()
    {
        return globalConfig.getDeclaredSettings();
    }

    @Override
    public String toString( boolean includeNullValues )
    {
        return globalConfig.toString( includeNullValues );
    }

    @Override
    public Setting getSetting( String name )
    {
        return globalConfig.getSetting( name );
    }

    @Override
    public void init()
    {
    }

    @Override
    public void start()
    {
    }

    @Override
    public void stop() throws Exception
    {
    }

    @Override
    public void shutdown()
    {
        for ( var settingListeners : registeredListeners.entrySet() )
        {
            Setting setting = settingListeners.getKey();
            Collection> listeners = settingListeners.getValue();
            for ( SettingChangeListener listener : listeners )
            {
                globalConfig.removeListener( setting, listener );
            }
        }
        registeredListeners = new ConcurrentHashMap<>();
    }

    Config getGlobalConfig()
    {
        return globalConfig;
    }
}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy