Configuration Management

/**
 * Configuration manager for cluster client settings
 */
public final class ClusterClientConfigManager {
    /**
     * Apply new client configuration settings
     * @param config new configuration to apply
     */
    public static void applyNewConfig(ClusterClientConfig config);
    
    /**
     * Apply new server assignment configuration  
     * @param assignConfig new server assignment to apply
     */
    public static void applyNewAssignConfig(ClusterClientAssignConfig assignConfig);
    
    /**
     * Register property listener for server assignment changes
     * @param property property to listen for server assignment updates
     */
    public static void registerServerAssignProperty(SentinelProperty<ClusterClientAssignConfig> property);
    
    /**
     * Register property listener for client configuration changes
     * @param property property to listen for client config updates
     */
    public static void registerClientConfigProperty(SentinelProperty<ClusterClientConfig> property);
    
    /**
     * Add observer for server assignment changes
     * @param observer observer to notify on server changes
     */
    public static void addServerChangeObserver(ServerChangeObserver observer);
    
    /**
     * Get currently configured server host
     * @return server host string, or null if not configured
     */
    public static String getServerHost();
    
    /**
     * Get currently configured server port
     * @return server port number
     */
    public static int getServerPort();
    
    /**
     * Get current request timeout setting
     * @return request timeout in milliseconds
     */
    public static int getRequestTimeout();
    
    /**
     * Get current connection timeout setting
     * @return connection timeout in milliseconds
     */
    public static int getConnectTimeout();
    
    /**
     * Validate server assignment configuration
     * @param config configuration to validate
     * @return true if configuration is valid
     */
    public static boolean isValidAssignConfig(ClusterClientAssignConfig config);
    
    /**
     * Validate client configuration
     * @param config configuration to validate  
     * @return true if configuration is valid
     */
    public static boolean isValidClientConfig(ClusterClientConfig config);
}

import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientConfigManager;
import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientConfig;
import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientAssignConfig;

// Configure server assignment
ClusterClientAssignConfig serverConfig = new ClusterClientAssignConfig("cluster-server", 8719);
ClusterClientConfigManager.applyNewAssignConfig(serverConfig);

// Configure client settings
ClusterClientConfig clientConfig = new ClusterClientConfig().setRequestTimeout(5000);
ClusterClientConfigManager.applyNewConfig(clientConfig);

// Check current configuration
System.out.println("Server: " + ClusterClientConfigManager.getServerHost() + 
                   ":" + ClusterClientConfigManager.getServerPort());
System.out.println("Request timeout: " + ClusterClientConfigManager.getRequestTimeout());

// Validate configuration before applying
ClusterClientAssignConfig newConfig = new ClusterClientAssignConfig("invalid-host", -1);
if (ClusterClientConfigManager.isValidAssignConfig(newConfig)) {
    ClusterClientConfigManager.applyNewAssignConfig(newConfig);
} else {
    System.err.println("Invalid server configuration");
}

/**
 * Configuration settings for cluster client behavior
 */
public class ClusterClientConfig {
    /**
     * Create new client configuration with default settings
     */
    public ClusterClientConfig();
    
    /**
     * Get current request timeout setting
     * @return request timeout in milliseconds, or null if not set
     */
    public Integer getRequestTimeout();
    
    /**
     * Set request timeout for cluster requests
     * @param requestTimeout timeout in milliseconds (must be > 0)
     * @return this configuration instance for fluent chaining
     */
    public ClusterClientConfig setRequestTimeout(Integer requestTimeout);
    
    /**
     * Get string representation of configuration
     * @return formatted configuration string
     */
    public String toString();
}

// Create configuration with fluent API
ClusterClientConfig config = new ClusterClientConfig()
    .setRequestTimeout(3000);

// Apply configuration  
ClusterClientConfigManager.applyNewConfig(config);

// Create configuration step by step
ClusterClientConfig stepConfig = new ClusterClientConfig();
stepConfig.setRequestTimeout(10000);
ClusterClientConfigManager.applyNewConfig(stepConfig);

/**
 * Configuration for cluster server assignment
 */
public class ClusterClientAssignConfig {
    /**
     * Create empty server assignment configuration
     */
    public ClusterClientAssignConfig();
    
    /**
     * Create server assignment configuration with host and port
     * @param serverHost hostname or IP address of cluster server
     * @param serverPort port number of cluster server
     */
    public ClusterClientAssignConfig(String serverHost, Integer serverPort);
    
    /**
     * Get configured server host
     * @return server hostname or IP address
     */
    public String getServerHost();
    
    /**
     * Set server host
     * @param serverHost hostname or IP address
     * @return this configuration instance for fluent chaining
     */
    public ClusterClientAssignConfig setServerHost(String serverHost);
    
    /**
     * Get configured server port
     * @return server port number
     */
    public Integer getServerPort();
    
    /**
     * Set server port
     * @param serverPort port number (must be 1-65535)
     * @return this configuration instance for fluent chaining  
     */
    public ClusterClientAssignConfig setServerPort(Integer serverPort);
    
    /**
     * Get string representation of server assignment
     * @return formatted server assignment string
     */
    public String toString();
}

// Create with constructor
ClusterClientAssignConfig config1 = new ClusterClientAssignConfig("localhost", 8719);

// Create with fluent API
ClusterClientAssignConfig config2 = new ClusterClientAssignConfig()
    .setServerHost("cluster-server.example.com")
    .setServerPort(9090);

// Step-by-step configuration
ClusterClientAssignConfig config3 = new ClusterClientAssignConfig();
config3.setServerHost("10.0.1.100");
config3.setServerPort(8719);

// Apply any of these configurations
ClusterClientConfigManager.applyNewAssignConfig(config2);

/**
 * Observer interface for server assignment changes
 */
public interface ServerChangeObserver {
    /**
     * Called when cluster server assignment changes
     * @param assignConfig new server assignment configuration
     */
    void onRemoteServerChange(ClusterClientAssignConfig assignConfig);
}

// Create custom observer
ServerChangeObserver observer = new ServerChangeObserver() {
    @Override
    public void onRemoteServerChange(ClusterClientAssignConfig assignConfig) {
        System.out.println("Server changed to: " + assignConfig.getServerHost() + 
                          ":" + assignConfig.getServerPort());
        // Custom logic for server changes
        notifyApplicationComponents(assignConfig);
    }
};

// Register observer
ClusterClientConfigManager.addServerChangeObserver(observer);

// Lambda expression version (Java 8+)
ClusterClientConfigManager.addServerChangeObserver(assignConfig -> {
    System.out.println("New server: " + assignConfig);
    reconnectDependentServices();
});

/**
 * Configuration reader for startup parameters
 */
public class ClusterClientStartUpConfig {
    /**
     * Get maximum parameter serialization size from system properties
     * @return maximum bytes for parameter serialization, or null if not configured
     */
    public static Integer getMaxParamByteSize();
}

// Check startup configuration
Integer maxBytes = ClusterClientStartUpConfig.getMaxParamByteSize();
if (maxBytes != null) {
    System.out.println("Max parameter bytes: " + maxBytes);
} else {
    System.out.println("Using default parameter size limits");
}

// System property: -Dcsp.sentinel.cluster.max.param.byte.size=1024

import com.alibaba.csp.sentinel.property.DynamicSentinelProperty;
import com.alibaba.csp.sentinel.property.SentinelProperty;

// Create dynamic property for server assignment
SentinelProperty<ClusterClientAssignConfig> serverProperty = new DynamicSentinelProperty<>();
ClusterClientConfigManager.registerServerAssignProperty(serverProperty);

// Update server assignment dynamically
ClusterClientAssignConfig newServer = new ClusterClientAssignConfig("new-server", 8720);
serverProperty.updateValue(newServer);

// Configuration change will be automatically applied and observers notified

// Valid configurations
ClusterClientAssignConfig valid1 = new ClusterClientAssignConfig("localhost", 8719);
ClusterClientAssignConfig valid2 = new ClusterClientAssignConfig("192.168.1.100", 9090);

// Invalid configurations  
ClusterClientAssignConfig invalid1 = new ClusterClientAssignConfig("", 8719);    // blank host
ClusterClientAssignConfig invalid2 = new ClusterClientAssignConfig("host", -1); // invalid port
ClusterClientAssignConfig invalid3 = new ClusterClientAssignConfig("host", 70000); // port too high

System.out.println(ClusterClientConfigManager.isValidAssignConfig(valid1));   // true
System.out.println(ClusterClientConfigManager.isValidAssignConfig(invalid1)); // false