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

.hazelcast.5.1-BETA-1.source-code.hazelcast-client-config-4.1.xsd Maven / Gradle / Ivy

There is a newer version: 5.5.0
Show newest version





    
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
            
        
    
    
        
            
                
                    
                
            
        
    
    
        
            
        
        
            
                
                    Controls if missing replacement value should lead to stop the boot process.
                
            
            
                
            
        
    
    
        
            
        
        
    

    
        
            
        
        
            
                
                    Specifies whether the the discovery strategy is enabled or not. Value can be true or false.
                
            
        
        
            
                
                    The maximum amount of time Hazelcast is going to try to connect to a well known member
                    before giving up. Please check if the specific discovery strategy supports this property.
                
            
        
    
    
    
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
    

    
        
            
            
        
    

    
        
            
            
            
            
            
        
        
    

    
        
    

    
        
            
        
        
    

    
        
    
    
        
            
        
        
        
    
    
        
            
                
            
        
    
    
        
            
                If true, client will route the key based operations to owner of the key at
                the best effort.
                Note that it uses a cached version of
                com.hazelcast.core.PartitionService#getPartitions() and doesn't
                guarantee that the operation will always be executed on the
                owner. The cached table is updated every
                second.
            
        
        
            
        
    
    
        
            
                If true, client will redo the operations that were executing on the server
                and client lost
                the connection. This can be because of network, or simply
                because the member died.
                However it is not
                clear
                whether the application is performed or not. For
                idempotent operations this is harmless, but for
                non
                idempotent ones retrying
                can cause to undesirable effects. Note that the redo can perform on any
                member.
                If false, the operation will throw a RuntimeException that is wrapping a
                java.io.IOException.
            
        
        
            
        
    
    
        
            
                
            
        
    
    
        
            
                
                
                
                
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
    
    
        
            
                
            
        
        
            
                
            
        
    

    
        
            
                
                    
                        
                            
                            
                            
                        
                    
                
            
        
    
    
        
            
                
                    
                        
                    
                
            
        
    

    
    
        
            
        
    
    
        
            
            
            
            
            
            
            
            
            
            
            
                
                    
                        
                    
                
            
        
        
            
                
            
        
        
            
                
            
        
    
    
        
            
                
                    
                        
                            
                            
                        
                    
                
            
        
    
    
        
            
            
        
        
        
    
    
        
            
        
    
    
        
            
            
            
        
    
    
        
            
            
        
    
    
        
            
            
            
        
    
    
        
            
                
            
        
    
    
        
            
        
    
    
        
            
                
            
        
    
    

    
        
            
        
        
        
    

    
        
            
            
            
            
            
        
    

    
        
            
            
            
        
    

    
        
            
        
    
    
        
            One of membership-listener, instance-listener or migration-listener
            
        
        
            
        
    
    
        
            
                
                
                
                
            
            
        
    
    
        
            
        
    
    
        
            
        
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
        
        
            
                
                    
                    
                    
                    
                
            
        
    
    
        
            
        
        
    

    
        
            
            
            
            
            
            
            
            
        
    

    
        
            
            
            
            
        
    

    
        
            
            
            
            
            
        
    

    
        
        
        
        
    

    
        
        
        
        
    

    
        
            
            
            
        
    

    
        
            
            
        
    

    
        
            
            
            
                
                    
                        
                        
                    
                
            
            
            
            
            
                
                    
                        
                    
                
            
            
                
                    
                        
                    
                
            
            
                
                    
                        
                            
                                
                                    Global serializer class to be registered if no other serializer is applicable.
                                
                            
                        
                        
                    
                
            
            
            
                
                    
                        Basic protection against untrusted deserialization based on class/package blacklisting and
                        whitelisting.
                    
                
            
        
    
    
        
            
                
            
        
    
    
        
        
    
    
        
            
                
                    
                        
                            Java Serializable and Externalizable is prior to global serializer by default. If set true
                            the Java serialization step assumed to be handled by the global serializer.
                        
                    
                
            
        
    
    
        
            
                
                    
                        Blacklisted classes and packages, which are not allowed to be deserialized.
                    
                
            
            
                
                    
                        Whitelisted classes and packages, which are allowed to be deserialized. If the list is empty
                        (no class or package name provided) then all classes are allowed.
                    
                
            
        
        
            
                
                    Disables including default list entries (hardcoded in Hazelcast source code).
                
            
            
                
            
        
    
    
        
            
                
                    
                        Name of a class to be included in the list.
                    
                
            
            
                
                    
                        Name of a package to be included in the list.
                    
                
            
            
                
                    
                        Class name prefix to be included in the list.
                    
                
            
        
    

    
        
            
            
        
        
    

    
        
            
            
            
            
                
                    
                        
                        
                        
                        
                    
                
            
            
            
        
        
        
    

    
        
        
    

    
        
            
            
            
            
        
    

    
        
            
            
        
    

    
        
            
                Configuration for persistent memory (e.g. Intel Optane) devices.
            
        
        
            
                
                    
                        List of directories where the persistent memory
                        is mounted to. Requires the mode attribute of persistent-memory
                        to be MOUNTED (default).

                        If the specified directories are not unique either in the directories
                        themselves or in the NUMA nodes specified for them,
                        the configuration is treated as invalid. Setting the NUMA
                        node on the subset of the configured directories while leaving
                        not set on others also makes the configuration invalid.
                    
                
                
                    
                        
                    
                
            
        
        
            
                
                    Sets if using persistent memory as Hazelcast native memory is enabled.
                
            
        
        
            
                
                    Sets the operational mode of the persistent memory configured
                    on the machine.
                
            
        
    
    
        
            
                
                    
                        The persistent memory is mounted into the file system (also known as FS DAX mode).
                    
                
            
            
                
                    
                        The persistent memory is onlined as system memory (also known as KMEM DAX mode).
                    
                
            
        
    

    
        
            
                The directory where persistent memory is mounted to.

                If the specified directory id not unique either in the
                directory itself or in the NUMA node specified, the
                configuration will be treated as invalid. Setting the NUMA
                node on the subset of the configured directories while leaving
                not set on others also results in invalid configuration.
            
        
        
            
                
                    
                        
                            The NUMA node that the persistent memory mounted
                            to the given directory is attached to.

                            NUMA nodes have to be unique across the entire
                            persistent memory configuration, otherwise the
                            configuration will be treated as invalid. Similarly,
                            setting the NUMA node on the subset of the configured
                            directories while leaving not set on others also
                            results in invalid configuration.
                        
                    
                
            
        
    

    
        
            
                
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
            
        
        
    
    
        
            
                
                    
                        
                    
                
            

            
                
                    
                        
                    
                
            

        
        
            
                
                    True to enable User Code Deployment on this client, false otherwise.
                
            
        
    
    
        
            
        
    
    
        
            
                
                    
                        How many IDs are pre-fetched on the background when one call to newId() is made.
                        Value must be in the range 1..100,000, default is 100.
                    
                
                
                    
                        
                    
                
            
            
                
                    
                        For how long the pre-fetched IDs can be used. If this time elapses, new IDs will be fetched.
                        Time unit is milliseconds.
                        If value is <= 0, validity is unlimited. Default value is 600,000 (10 minutes).
                        The IDs contain timestamp component, which ensures rough global ordering of IDs. If an ID
                        is assigned to an event that occurred much later, it will be much out of order.
                        If you don't need ordering, set this value to 0.
                    
                
            
        
        
            
                
                    Name of the ID generator.
                
            
            
                
            
        
    

    
        
            
                
                    
                        Policy to deal with an overloaded topic; so topic where there is no place to store new messages.
                        Options are
                        DISCARD_OLDEST: Using this policy, a message that has not expired can be overwritten.
                        No matter the retention period set, the overwrite will just overwrite the item.
                        DISCARD_NEWEST : The message that was to be published, is discarded.
                        BLOCK : The caller will wait till there space in the ringbuffer.
                        ERROR : The publish call immediately fails.(Default Value)
                    
                
                
                    
                        
                        
                        
                        
                    
                
            
            
                
                    
                        The maximum number of items to read in a batch.
                    
                
            
        
        
            
                
                    Name of the Reliable Topic.
                
            
            
                
            
        
    
    
        
        
    
    
        
            
                
                    
                        
                            
                            
                        
                    
                
            
        
    
    
        
            
            
            
            
            
            
            
        
    

    
        
            
            
                
                    
                        Sets the metrics collection frequency in seconds.
                        By default, metrics are collected every 5 seconds.
                        May be overridden by 'hazelcast.metrics.collection.frequency'
                        system property.
                    
                
            
        
        
            
                
                    Master-switch for the metrics system. Controls whether
                    the metrics are collected and publishers are enabled.
                    May be overridden by 'hazelcast.metrics.enabled'
                    system property.
                
            
        
    

    
        
            
                
                    Controls whether the metrics collected are exposed to
                    through JMX. It is enabled by default.
                    In order to expose the metrics, the metrics system need
                    to be enabled via the enabled master-switch attribute.
                    May be overridden by 'hazelcast.metrics.jmx.enabled'
                    system property.
                
            
        
    

    
        
            
                Configures tracking of a running Hazelcast instance. For now, this is
                limited to writing information about the Hazelcast instance to a file
                while the instance is starting.
                The file is overwritten on every start of the Hazelcast instance and if
                multiple instance share the same file system, every instance will
                overwrite the tracking file of a previously started instance.
                If this instance is unable to write the file, the exception is logged and
                the instance is allowed to start.
            
        
        
            
                
                    
                        Sets the name of the file which will contain the tracking metadata. If left unset
                        a file named "Hazelcast.process" will be created in the directory as returned by
                        System.getProperty("java.io.tmpdir").
                        The filename can contain placeholders that will be resolved in the same way
                        as placeholders for the format pattern.
                    
                
            
            
                
                    
                        Sets the pattern used to render the contents of the instance tracking file.
                        It may contain placeholders for these properties:
                        - "product": The instance product name, e.g. "Hazelcast" or "Hazelcast Enterprise".
                        - "version": The instance version.
                        - "mode": The instance mode which can be "server", "embedded" or "client".
                        - "start_timestamp": The timestamp of when the instance was started expressed the difference,
                        measured in milliseconds, between the current time and midnight, January 1, 1970 UTC
                        - "licensed": If this instance is using a license or not. The value 0 signifies
                        that there is no license set and the value 1 signifies that a license is in use.
                        - "pid": Attempts to get the process ID value. The algorithm does not guarantee to get the
                        process ID on all JVMs and operating systems so please test before use. In case we are unable to
                        get the PID, the value will be -1.

                        The placeholders are defined by a $HZ_INSTANCE_TRACKING{ prefix and followed by }.
                        For instance, a placeholder for the "start_timestamp" would be $HZ_INSTANCE_TRACKING{start_timestamp}.
                        The placeholders are resolved in a fail-safe manner. Any incorrect syntax
                        is ignored and only the known properties are resolved, placeholders for
                        any parameters which do not have defined values will be ignored. This also
                        means that if there is a missing closing bracket in one of the placeholders,
                        the property name will be resolved as anything from the opening bracket
                        to the next closing bracket, which might contain additional opening brackets.
                        If unset, a JSON formatted output will be used.
                    
                
            
        
        
            
                
                    Enables or disables instance tracking.
                
            
        
    





© 2015 - 2024 Weber Informatics LLC | Privacy Policy