Java BlobPath.cleanPath方法代码示例

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs a read-only URL-based repository
 */
public URLRepository(RepositoryMetaData metadata, Environment environment,
                     NamedXContentRegistry namedXContentRegistry) throws IOException {
    super(metadata, environment.settings(), namedXContentRegistry);

    if (URL_SETTING.exists(metadata.settings()) == false && REPOSITORIES_URL_SETTING.exists(settings) ==  false) {
        throw new RepositoryException(metadata.name(), "missing url");
    }
    supportedProtocols = SUPPORTED_PROTOCOLS_SETTING.get(settings);
    urlWhiteList = ALLOWED_URLS_SETTING.get(settings).toArray(new URIPattern[]{});
    this.environment = environment;

    URL url = URL_SETTING.exists(metadata.settings()) ? URL_SETTING.get(metadata.settings()) : REPOSITORIES_URL_SETTING.get(settings);
    URL normalizedURL = checkURL(url);
    blobStore = new URLBlobStore(settings, normalizedURL);
    basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs new shared file system repository
 *
 * @param name                 repository name
 * @param repositorySettings   repository settings
 * @param indexShardRepository index shard repository
 */
@Inject
public FsRepository(RepositoryName name, RepositorySettings repositorySettings, IndexShardRepository indexShardRepository, Environment environment) throws IOException {
    super(name.getName(), repositorySettings, indexShardRepository);
    Path locationFile;
    String location = repositorySettings.settings().get("location", settings.get("repositories.fs.location"));
    if (location == null) {
        logger.warn("the repository location is missing, it should point to a shared file system location that is available on all master and data nodes");
        throw new RepositoryException(name.name(), "missing location");
    }
    locationFile = environment.resolveRepoFile(location);
    if (locationFile == null) {
        if (environment.repoFiles().length > 0) {
            logger.warn("The specified location [{}] doesn't start with any repository paths specified by the path.repo setting: [{}] ", location, environment.repoFiles());
            throw new RepositoryException(name.name(), "location [" + location + "] doesn't match any of the locations specified by path.repo");
        } else {
            logger.warn("The specified location [{}] should start with a repository path specified by the path.repo setting, but the path.repo setting was not set on this node", location);
            throw new RepositoryException(name.name(), "location [" + location + "] doesn't match any of the locations specified by path.repo because this setting is empty");
        }
    }

    blobStore = new FsBlobStore(settings, locationFile);
    this.chunkSize = repositorySettings.settings().getAsBytesSize("chunk_size", settings.getAsBytesSize("repositories.fs.chunk_size", null));
    this.compress = repositorySettings.settings().getAsBoolean("compress", settings.getAsBoolean("repositories.fs.compress", false));
    this.basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs new BlobStoreRepository
 * @param name                 repository name
 * @param repositorySettings   repository settings
 * @param indexShardRepository an instance of IndexShardRepository
 * @param gridFsService and instance of GridFsService
 */
@Inject
protected GridFsRepository(RepositoryName name, RepositorySettings repositorySettings, IndexShardRepository indexShardRepository, GridFsService gridFsService) {
    super(name.getName(), repositorySettings, indexShardRepository);

    String database = repositorySettings.settings().get("database", componentSettings.get("database"));
    if (database == null) {
        throw new RepositoryException(name.name(), "No database defined for GridFS repository");
    }

    String bucket = repositorySettings.settings().get("bucket", "fs");
    String host = repositorySettings.settings().get("gridfs_host", "localhost");
    int port = repositorySettings.settings().getAsInt("gridfs_port", 27017);
    String username = repositorySettings.settings().get("gridfs_username");
    String password = repositorySettings.settings().get("gridfs_password");

    int concurrentStreams = repositorySettings.settings().getAsInt("concurrent_streams", componentSettings.getAsInt("concurrent_streams", 5));
    ExecutorService concurrentStreamPool = EsExecutors.newScaling(1, concurrentStreams, 5, TimeUnit.SECONDS, EsExecutors.daemonThreadFactory(settings, "[gridfs_stream]"));
    blobStore = new GridFsBlobStore(settings, gridFsService.mongoDB(host, port, database, username, password), bucket, concurrentStreamPool);
    this.chunkSize = repositorySettings.settings().getAsBytesSize("chunk_size", componentSettings.getAsBytesSize("chunk_size", null));
    this.compress = repositorySettings.settings().getAsBoolean("compress", componentSettings.getAsBoolean("compress", true));
    this.basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
@Inject
public SshRepository(final RepositoryName name,
    final RepositorySettings repositorySettings,
    final IndexShardRepository indexShardRepository,
    final ThreadPool threadPool) throws IOException {
    super(name.getName(), repositorySettings, indexShardRepository);

    try {
        blobStore = new SshBlobStore(settings, new JSchClient(
            settings, repositorySettings, threadPool));
    } catch (final JSchException e) {
        throw new RepositoryException(name.name(),
            "Failed to initialize SSH configuration.", e);
    }

    chunkSize = repositorySettings.settings().getAsBytesSize("chunk_size",
        settings.getAsBytesSize("chunk_size", null));
    compress = repositorySettings.settings().getAsBoolean("compress",
        settings.getAsBoolean("compress", false));
    basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs a shared file system repository.
 */
public FsRepository(RepositoryMetaData metadata, Environment environment,
                    NamedXContentRegistry namedXContentRegistry) throws IOException {
    super(metadata, environment.settings(), namedXContentRegistry);
    String location = REPOSITORIES_LOCATION_SETTING.get(metadata.settings());
    if (location.isEmpty()) {
        logger.warn("the repository location is missing, it should point to a shared file system location that is available on all master and data nodes");
        throw new RepositoryException(metadata.name(), "missing location");
    }
    Path locationFile = environment.resolveRepoFile(location);
    if (locationFile == null) {
        if (environment.repoFiles().length > 0) {
            logger.warn("The specified location [{}] doesn't start with any repository paths specified by the path.repo setting: [{}] ", location, environment.repoFiles());
            throw new RepositoryException(metadata.name(), "location [" + location + "] doesn't match any of the locations specified by path.repo");
        } else {
            logger.warn("The specified location [{}] should start with a repository path specified by the path.repo setting, but the path.repo setting was not set on this node", location);
            throw new RepositoryException(metadata.name(), "location [" + location + "] doesn't match any of the locations specified by path.repo because this setting is empty");
        }
    }

    blobStore = new FsBlobStore(settings, locationFile);
    if (CHUNK_SIZE_SETTING.exists(metadata.settings())) {
        this.chunkSize = CHUNK_SIZE_SETTING.get(metadata.settings());
    } else if (REPOSITORIES_CHUNK_SIZE_SETTING.exists(settings)) {
        this.chunkSize = REPOSITORIES_CHUNK_SIZE_SETTING.get(settings);
    } else {
        this.chunkSize = null;
    }
    this.compress = COMPRESS_SETTING.exists(metadata.settings()) ? COMPRESS_SETTING.get(metadata.settings()) : REPOSITORIES_COMPRESS_SETTING.get(settings);
    this.basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
public AzureRepository(RepositoryMetaData metadata, Environment environment,
                       NamedXContentRegistry namedXContentRegistry, AzureStorageService storageService)
    throws IOException, URISyntaxException, StorageException {
    super(metadata, environment.settings(), namedXContentRegistry);

    blobStore = new AzureBlobStore(metadata, environment.settings(), storageService);
    String container = getValue(metadata.settings(), settings, Repository.CONTAINER_SETTING, Storage.CONTAINER_SETTING);
    this.chunkSize = getValue(metadata.settings(), settings, Repository.CHUNK_SIZE_SETTING, Storage.CHUNK_SIZE_SETTING);
    this.compress = getValue(metadata.settings(), settings, Repository.COMPRESS_SETTING, Storage.COMPRESS_SETTING);
    String modeStr = getValue(metadata.settings(), settings, Repository.LOCATION_MODE_SETTING, Storage.LOCATION_MODE_SETTING);
    Boolean forcedReadonly = metadata.settings().getAsBoolean("readonly", null);
    // If the user explicitly did not define a readonly value, we set it by ourselves depending on the location mode setting.
    // For secondary_only setting, the repository should be read only
    if (forcedReadonly == null) {
        if (Strings.hasLength(modeStr)) {
            LocationMode locationMode = LocationMode.valueOf(modeStr.toUpperCase(Locale.ROOT));
            this.readonly = locationMode == LocationMode.SECONDARY_ONLY;
        } else {
            this.readonly = false;
        }
    } else {
        readonly = forcedReadonly;
    }

    String basePath = getValue(metadata.settings(), settings, Repository.BASE_PATH_SETTING, Storage.BASE_PATH_SETTING);

    if (Strings.hasLength(basePath)) {
        // Remove starting / if any
        basePath = Strings.trimLeadingCharacter(basePath, '/');
        BlobPath path = new BlobPath();
        for(String elem : basePath.split("/")) {
            path = path.add(elem);
        }
        this.basePath = path;
    } else {
        this.basePath = BlobPath.cleanPath();
    }
    logger.debug("using container [{}], chunk_size [{}], compress [{}], base_path [{}]",
            container, chunkSize, compress, basePath);
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
@Inject
protected CloudFilesRepository(String repositoryName, RepositorySettings repositorySettings, IndexShardRepository indexShardRepository, CloudFilesService cloudFilesService) {
    super(repositoryName, repositorySettings, indexShardRepository);

    final String container = repositorySettings.settings().get("container", componentSettings.get("container"));
    if(container == null || container.equals("")){
        throw new RepositoryException(repositoryName, "No container defined for cloud files gateway.");
    }

    final String dataCenter = repositorySettings.settings().get("region", componentSettings.get("region", "ORD"));
    final int concurrentStreams = repositorySettings.settings().getAsInt("concurrent_streams", componentSettings.getAsInt("concurrent_streams", 5));
    ExecutorService concurrentStreamPool = EsExecutors.newScaling(1, concurrentStreams, 5, TimeUnit.SECONDS, EsExecutors.daemonThreadFactory(settings, "[cloudfiles_stream]"));
    final Location location = new LocationBuilder()
            .scope(LocationScope.REGION)
            .id(dataCenter)
            .description(String.format("Rackspace's %s datacenter.", dataCenter))
            .build();

    blobStore = new CloudFilesBlobStore(settings, cloudFilesService.context(), container, location, concurrentStreamPool);
    this.chunkSize = repositorySettings.settings().getAsBytesSize("chunk_size", componentSettings.getAsBytesSize("chunk_size", new ByteSizeValue(100, ByteSizeUnit.MB)));
    this.compress = repositorySettings.settings().getAsBoolean("compress", componentSettings.getAsBoolean("compress", false));
    logger.debug("using container [{}], data center [{}], chunk_size [{}], concurrent_streams [{}]", container, dataCenter, chunkSize, concurrentStreams);
    String basePath = repositorySettings.settings().get("base_path", null);
    if (Strings.hasLength(basePath)) {
        BlobPath path = new BlobPath();
        for(String elem : Strings.splitStringToArray(basePath, '/')) {
            path = path.add(elem);
        }
        this.basePath = path;
    } else {
        this.basePath = BlobPath.cleanPath();
    }
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs new BlobStoreRepository
 * 
 * @param name
 *            repository name
 * @param repositorySettings
 *            repository settings
 * @param indexShardRepository
 *            an instance of IndexShardRepository
 * @param swiftService
 *            an instance of SwiftService
 */
@Inject
public SwiftRepository(RepositoryName name, RepositorySettings repositorySettings, IndexShardRepository indexShardRepository, SwiftService swiftService) {
    super(name.getName(), repositorySettings, indexShardRepository);

    String url = repositorySettings.settings().get("swift_url");
    if (url == null) {
        throw new RepositoryException(name.name(), "No url defined for swift repository");
    }

    String container = repositorySettings.settings().get("swift_container");
    if (container == null) {
        throw new RepositoryException(name.name(), "No container defined for swift repository");
    }

    String username = repositorySettings.settings().get("swift_username", "");
    String password = repositorySettings.settings().get("swift_password", "");
    String tenantName = repositorySettings.settings().get("swift_tenantname", "");
    String authMethod = repositorySettings.settings().get("swift_authmethod", "");
    String preferredRegion = repositorySettings.settings().get("swift_preferred_region", null);
    Account account = SwiftAccountFactory.createAccount(swiftService, url, username, password, tenantName, authMethod, preferredRegion);

    blobStore = new SwiftBlobStore(settings, account, container);
    this.chunkSize = repositorySettings.settings().getAsBytesSize("chunk_size",
            settings.getAsBytesSize("chunk_size", new ByteSizeValue(5, ByteSizeUnit.GB)));
    this.compress = repositorySettings.settings().getAsBoolean("compress",
            settings.getAsBoolean("compress", false));
    this.basePath = BlobPath.cleanPath();
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
public GoogleCloudStorageRepository(RepositoryMetaData metadata, Environment environment,
                                    NamedXContentRegistry namedXContentRegistry,
                                    GoogleCloudStorageService storageService) throws Exception {
    super(metadata, environment.settings(), namedXContentRegistry);

    String bucket = getSetting(BUCKET, metadata);
    String application = getSetting(APPLICATION_NAME, metadata);
    String serviceAccount = getSetting(SERVICE_ACCOUNT, metadata);

    String basePath = BASE_PATH.get(metadata.settings());
    if (Strings.hasLength(basePath)) {
        BlobPath path = new BlobPath();
        for (String elem : basePath.split("/")) {
            path = path.add(elem);
        }
        this.basePath = path;
    } else {
        this.basePath = BlobPath.cleanPath();
    }

    TimeValue connectTimeout = null;
    TimeValue readTimeout = null;

    TimeValue timeout = HTTP_CONNECT_TIMEOUT.get(metadata.settings());
    if ((timeout != null) && (timeout.millis() != NO_TIMEOUT.millis())) {
        connectTimeout = timeout;
    }

    timeout = HTTP_READ_TIMEOUT.get(metadata.settings());
    if ((timeout != null) && (timeout.millis() != NO_TIMEOUT.millis())) {
        readTimeout = timeout;
    }

    this.compress = getSetting(COMPRESS, metadata);
    this.chunkSize = getSetting(CHUNK_SIZE, metadata);

    logger.debug("using bucket [{}], base_path [{}], chunk_size [{}], compress [{}], application [{}]",
            bucket, basePath, chunkSize, compress, application);

    Storage client = storageService.createClient(serviceAccount, application, connectTimeout, readTimeout);
    this.blobStore = new GoogleCloudStorageBlobStore(settings, bucket, client);
}
 

import org.elasticsearch.common.blobstore.BlobPath; //导入方法依赖的package包/类
/**
 * Constructs an s3 backed repository
 */
public S3Repository(RepositoryMetaData metadata, Settings settings,
                    NamedXContentRegistry namedXContentRegistry, AwsS3Service s3Service) throws IOException {
    super(metadata, settings, namedXContentRegistry);

    String bucket = getValue(metadata.settings(), settings, Repository.BUCKET_SETTING, Repositories.BUCKET_SETTING);
    if (bucket == null) {
        throw new RepositoryException(metadata.name(), "No bucket defined for s3 gateway");
    }

    boolean serverSideEncryption = getValue(metadata.settings(), settings, Repository.SERVER_SIDE_ENCRYPTION_SETTING, Repositories.SERVER_SIDE_ENCRYPTION_SETTING);
    ByteSizeValue bufferSize = getValue(metadata.settings(), settings, Repository.BUFFER_SIZE_SETTING, Repositories.BUFFER_SIZE_SETTING);
    Integer maxRetries = getValue(metadata.settings(), settings, Repository.MAX_RETRIES_SETTING, Repositories.MAX_RETRIES_SETTING);
    boolean useThrottleRetries = getValue(metadata.settings(), settings, Repository.USE_THROTTLE_RETRIES_SETTING, Repositories.USE_THROTTLE_RETRIES_SETTING);
    this.chunkSize = getValue(metadata.settings(), settings, Repository.CHUNK_SIZE_SETTING, Repositories.CHUNK_SIZE_SETTING);
    this.compress = getValue(metadata.settings(), settings, Repository.COMPRESS_SETTING, Repositories.COMPRESS_SETTING);

    // We make sure that chunkSize is bigger or equal than/to bufferSize
    if (this.chunkSize.getBytes() < bufferSize.getBytes()) {
        throw new RepositoryException(metadata.name(), Repository.CHUNK_SIZE_SETTING.getKey() + " (" + this.chunkSize +
            ") can't be lower than " + Repository.BUFFER_SIZE_SETTING.getKey() + " (" + bufferSize + ").");
    }

    // Parse and validate the user's S3 Storage Class setting
    String storageClass = getValue(metadata.settings(), settings, Repository.STORAGE_CLASS_SETTING, Repositories.STORAGE_CLASS_SETTING);
    String cannedACL = getValue(metadata.settings(), settings, Repository.CANNED_ACL_SETTING, Repositories.CANNED_ACL_SETTING);

    // If the user defined a path style access setting, we rely on it otherwise we use the default
    // value set by the SDK
    Boolean pathStyleAccess = null;
    if (Repository.PATH_STYLE_ACCESS_SETTING.exists(metadata.settings()) ||
        Repositories.PATH_STYLE_ACCESS_SETTING.exists(settings)) {
        pathStyleAccess = getValue(metadata.settings(), settings, Repository.PATH_STYLE_ACCESS_SETTING, Repositories.PATH_STYLE_ACCESS_SETTING);
    }

    logger.debug("using bucket [{}], chunk_size [{}], server_side_encryption [{}], " +
        "buffer_size [{}], max_retries [{}], use_throttle_retries [{}], cannedACL [{}], storageClass [{}], path_style_access [{}]",
        bucket, chunkSize, serverSideEncryption, bufferSize, maxRetries, useThrottleRetries, cannedACL,
        storageClass, pathStyleAccess);

    AmazonS3 client = s3Service.client(metadata.settings(), maxRetries, useThrottleRetries, pathStyleAccess);
    blobStore = new S3BlobStore(settings, client, bucket, serverSideEncryption, bufferSize, maxRetries, cannedACL, storageClass);

    String basePath = getValue(metadata.settings(), settings, Repository.BASE_PATH_SETTING, Repositories.BASE_PATH_SETTING);
    if (Strings.hasLength(basePath)) {
        if (basePath.startsWith("/")) {
            basePath = basePath.substring(1);
            deprecationLogger.deprecated("S3 repository base_path trimming the leading `/`, and " +
                                             "leading `/` will not be supported for the S3 repository in future releases");
        }
        this.basePath = new BlobPath().add(basePath);
    } else {
        this.basePath = BlobPath.cleanPath();
    }
}