labels.target=Objetivo
labels.token=Token
labels.synonymFile=Archivo de sinónimos
labels.stopwordsFile=Archivo de palabras vacías
labels.stemmerOverrideFile=Archivo de anulación de Stemmer
labels.mappingFile=Archivo de mapeo
labels.protwordsFile=Archivo Protwords
labels.kuromojiFile=Archivo Kuromoji
labels.elevateWordFile=Archivo de palabras elevadas
labels.badWordFile=Archivo de palabras no deseadas
labels.urlExpr=Condición

         * @return true if watching is active
         */
        public boolean isActive() {
            return active;
        }

        /**
         * Set active status
         *
         * @param active true to activate
         */
        public void setActive(boolean active) {
            this.active = active;
        }

        /**

        private final SmbFile directoryFile;
        private volatile boolean active;
        
        public ChangeNotificationHandle(String path, Smb2LeaseKey key, SmbFile dir) {
            this.directoryPath = path;
            this.leaseKey = key;
            this.directoryFile = dir;
            this.active = true;
        }
    }
    

plication.html) page. The [Bucket Replication](https://docs.min.io/community/minio-object-store/administration/bucket-replication/bucket-replication-requirements.html) page references dedicated tutorials for configuring one-way "Active-Passive" and two-way "Active-Active" bucket replication.

To replicate objects in a bucket to a destination bucket on a target site either in the same cluster or a different cluster, start by enabling [versioning](https://docs.min.io/community/minio-object-s...

We want to get the `current_user` *only* if this user is active.

So, we create an additional dependency `get_current_active_user` that in turn uses `get_current_user` as a dependency.

Both of these dependencies will just return an HTTP error if the user doesn't exist, or if is inactive.

So, in our endpoint, we will only get a user if the user exists, was correctly authenticated, and is active:

        public int initializingShards;
        /** Number of relocating shards */
        public int relocatingShards;
        /** Percentage of active shards */
        public double activeShardsPercent;
        /** Number of active shards */
        public int activeShards;
        /** Number of active primary shards */
        public int activePrimaryShards;
        /** Number of data nodes */
        public int numberOfDataNodes;

	atomic.AddUint64(&p.operations[s], 1)
	if s < scannerMetricLastRealtime {
		p.latency[s].add(d)
	}
}

// timeILM times an ILM action.
// lifecycle.NoneAction is ignored.
// Use for s < scannerMetricLastRealtime
func (p *scannerMetrics) timeILM(a lifecycle.Action) func(versions uint64) {
	if a == lifecycle.NoneAction || a >= lifecycle.ActionCount {
		return func(_ uint64) {}
	}
	startTime := time.Now()

| `minio_node_replication_average_active_workers`         | Average number of active replication workers                                                             |

## Prerequisites

        assertNotNull(stats.get("activeResources"));
        assertNotNull(stats.get("closedResources"));
    }

    @Test
    @DisplayName("Test get active resources")
    void testGetActiveResources() {
        TestResource resource = new TestResource("active1");
        resourceManager.registerResource(resource);

        var activeResources = resourceManager.getActiveResources();
        assertNotNull(activeResources);