/** The key of the configuration. e.g. true */
    String FTP_ROLE_FROM_FILE = "ftp.role.from.file";

    /** The key of the configuration. e.g. fess_basic_config.bulk,fess_config.bulk,fess_user.bulk,system.properties,fess.json,doc.json */
    String INDEX_BACKUP_TARGETS = "index.backup.targets";

import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opensearch.action.admin.indices.get.GetIndexResponse;
import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.index.IndexAction;
import org.opensearch.action.index.IndexRequestBuilder;
import org.opensearch.action.support.WriteRequest;
import org.opensearch.client.Client;

   * in the returned list.
   *
   * <p>The function is applied lazily, invoked when needed. This is necessary for the returned list
   * to be a view, but it means that the function will be applied many times for bulk operations
   * like {@link List#contains} and {@link List#hashCode}. For this to perform well, {@code
   * function} should be fast. To avoid lazy evaluation when the returned list doesn't need to be a

labels.notification_login=Страница входа
labels.notification_search_top=Главная страница поиска
labels.send_testmail=Send TestMail
labels.backup_configuration=Back Up
labels.backup_name=Name
labels.backup_bulk_file=Bulk File
labels.backup_button_upload=Upload
labels.process_time_is_exceeded=Лимит времени поиска был превышен. Частичный результат может отображаться.
labels.user_given_name=Имя
labels.givenName=Имя

	errs := statAllDirs(ctx, storageDisks, bucket, object)
	danglingObject := isObjectDirDangling(errs)
	if danglingObject {
		if !dryRun && remove {
			var wg sync.WaitGroup
			// Remove versions in bulk for each disk
			for index, disk := range storageDisks {
				if disk == nil {
					continue
				}
				wg.Add(1)
				go func(index int, disk StorageAPI) {
					defer wg.Done()

			t.Fatalf("TestXLStorage %d:  Expected the error to be : \"%v\", got: \"%v\".", i+1, testCase.expectedErr, err)
		}
	}
}

// TestXLStorageDeleteVersion will test if version deletes and bulk deletes work as expected.
func TestXLStorageDeleteVersion(t *testing.T) {
	// create xlStorage test setup
	xl, _, err := newXLStorageTestSetup(t)
	if err != nil {

	}
	volume := r.Form.Get(storageRESTVolume)
	err := s.getStorage().MakeVol(r.Context(), volume)
	if err != nil {
		s.writeErrorResponse(w, err)
	}
}

// MakeVolBulkHandler - create multiple volumes as a bulk operation.
func (s *storageRESTServer) MakeVolBulkHandler(w http.ResponseWriter, r *http.Request) {
	if !s.IsValid(w, r) {
		return
	}
	volumes := strings.Split(r.Form.Get(storageRESTVolumes), ",")

    /** The key of the message: Started reindexing. */
    public static final String SUCCESS_reindex_started = "{success.reindex_started}";

    /** The key of the message: Bulk process is started. */
    public static final String SUCCESS_bulk_process_started = "{success.bulk_process_started}";

    /** The key of the message: Printed thread dump to log file. */

    /** The key of the message: Upload File */
    public static final String LABELS_DESIGN_FILE = "{labels.designFile}";

    /** The key of the message: Bulk File */
    public static final String LABELS_BULK_FILE = "{labels.bulkFile}";

    /** The key of the message: Additional Query Parameters */

     * which are awaiting cleanup.
     */
    volatile int count;

    /**
     * Number of updates that alter the size of the table. This is used during bulk-read methods to
     * make sure they see a consistent snapshot: If modCounts change during a traversal of segments
     * computing size or checking containsValue, then we might have an inconsistent view of state so