import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Deletes repositories, supports wildcard notation.
 */
public void wipeRepositories(String... repositories) {
    if (size() > 0) {
        // if nothing is provided, delete all
        if (repositories.length == 0) {
            repositories = new String[]{"*"};
        }
        for (String repository : repositories) {
            try {
                client().admin().cluster().prepareDeleteRepository(repository).execute().actionGet();
            } catch (RepositoryMissingException ex) {
                // ignore
            }
        }
    }
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
public void deleteMissingRepositories() {

		Utils.info("[SpaceDog] deleting missing repositories ...");

		List<RepositoryMetaData> repositories = elastic().cluster()//
				.prepareGetRepositories().get().repositories();

		for (RepositoryMetaData repository : repositories) {
			try {
				elastic().cluster()//
						.prepareVerifyRepository(repository.name()).get();

				Utils.info("[SpaceDog] repository [%s] OK", repository.name());

			} catch (RepositoryMissingException e) {

				elastic().cluster()//
						.prepareDeleteRepository(repository.name()).get();

				Utils.info("[SpaceDog] repository [%s] deleted because missing", repository.name());
			}
		}
	}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * TODO does not delete very obsolete repo if one is missing in between
 */
public void deleteObsoleteRepositories() {

	Utils.info("[SpaceDog] deleting obsolete repositories ...");

	String currentRepositoryId = ElasticRepository.getCurrentRepositoryId();
	String obsoleteRepositoryId = ElasticRepository.getPreviousRepositoryId(currentRepositoryId, 4);

	while (true) {
		try {

			elastic().cluster()//
					.prepareDeleteRepository(obsoleteRepositoryId)//
					.get();

			Utils.info("[SpaceDog] repository [%s] deleted because obsolete", obsoleteRepositoryId);

			obsoleteRepositoryId = ElasticRepository.getPreviousRepositoryId(//
					obsoleteRepositoryId, 1);

		} catch (RepositoryMissingException e) {
			break;
		}
	}
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Validates snapshot request
 *
 * @param request snapshot request
 * @param state   current cluster state
 */
private void validate(SnapshotRequest request, ClusterState state) {
    RepositoriesMetaData repositoriesMetaData = state.getMetaData().custom(RepositoriesMetaData.TYPE);
    final String repository = request.repositoryName;
    if (repositoriesMetaData == null || repositoriesMetaData.repository(repository) == null) {
        throw new RepositoryMissingException(repository);
    }
    validate(repository, request.snapshotName);
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Deletes repositories, supports wildcard notation.
 */
public static void wipeRepositories(String... repositories) {
    // if nothing is provided, delete all
    if (repositories.length == 0) {
        repositories = new String[]{"*"};
    }
    for (String repository : repositories) {
        try {
            client().admin().cluster().prepareDeleteRepository(repository).get();
        } catch (RepositoryMissingException ex) {
            // ignore
        }
    }
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Deletes repositories, supports wildcard notation.
 */
public static void wipeRepositories(String... repositories) {
    // if nothing is provided, delete all
    if (repositories.length == 0) {
        repositories = new String[]{"*"};
    }
    for (String repository : repositories) {
        try {
            client().admin().cluster().prepareDeleteRepository(repository).execute().actionGet();
        } catch (RepositoryMissingException ex) {
            // ignore
        }
    }
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Returns the cause throwable of a {@link org.elasticsearch.transport.RemoteTransportException}
 * and {@link org.elasticsearch.action.search.ReduceSearchPhaseException}.
 * Also transform throwable to {@link io.crate.exceptions.CrateException}.
 */
private Throwable esToCrateException(Throwable e) {
    e = Exceptions.unwrap(e);

    if (e instanceof IllegalArgumentException || e instanceof ParsingException) {
        return new SQLParseException(e.getMessage(), (Exception) e);
    } else if (e instanceof UnsupportedOperationException) {
        return new UnsupportedFeatureException(e.getMessage(), (Exception) e);
    } else if (e instanceof DocumentAlreadyExistsException) {
        return new DuplicateKeyException(
                "A document with the same primary key exists already", e);
    } else if (e instanceof IndexAlreadyExistsException) {
        return new TableAlreadyExistsException(((IndexAlreadyExistsException) e).getIndex(), e);
    } else if ((e instanceof InvalidIndexNameException)) {
        if (e.getMessage().contains("already exists as alias")) {
            // treat an alias like a table as aliases are not officially supported
            return new TableAlreadyExistsException(((InvalidIndexNameException) e).getIndex(),
                    e);
        }
        return new InvalidTableNameException(((InvalidIndexNameException) e).getIndex(), e);
    } else if (e instanceof InvalidIndexTemplateException) {
        PartitionName partitionName = PartitionName.fromIndexOrTemplate(((InvalidIndexTemplateException) e).name());
        return new InvalidTableNameException(partitionName.tableIdent().fqn(), e);
    } else if (e instanceof IndexNotFoundException) {
        return new TableUnknownException(((IndexNotFoundException) e).getIndex(), e);
    } else if (e instanceof org.elasticsearch.common.breaker.CircuitBreakingException) {
        return new CircuitBreakingException(e.getMessage());
    } else if (e instanceof InterruptedException) {
        return new JobKilledException();
    } else if (e instanceof RepositoryMissingException) {
        return new RepositoryUnknownException(((RepositoryMissingException) e).repository());
    } else if (e instanceof SnapshotMissingException) {
        return new SnapshotUnknownException(((SnapshotMissingException) e).snapshot(), e);
    } else if (e instanceof InvalidSnapshotNameException) {
        if (((InvalidSnapshotNameException) e).getDetailedMessage().contains("snapshot with such name already exists")) {
            return new SnapShotAlreadyExistsExeption(((InvalidSnapshotNameException) e).snapshot());
        }
    }
    return e;
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
/**
 * Validates snapshot request
 *
 * @param request snapshot request
 * @param state   current cluster state
 */
private void validate(SnapshotRequest request, ClusterState state) {
    RepositoriesMetaData repositoriesMetaData = state.getMetaData().custom(RepositoriesMetaData.TYPE);
    if (repositoriesMetaData == null || repositoriesMetaData.repository(request.repository()) == null) {
        throw new RepositoryMissingException(request.repository());
    }
    validate(new SnapshotId(request.repository(), request.name()));
}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
static String getOrCreateRepositoryFor(DateTime date) {

		String repoId = ElasticRepository.toRepositoryId(date);

		try {
			SnapshotResource.elastic().cluster()//
					.prepareGetRepositories(repoId)//
					.get();

		} catch (RepositoryMissingException e) {

			ElasticRepository repo = new ElasticRepository(repoId);

			PutRepositoryResponse putRepositoryResponse = SnapshotResource.elastic().cluster()//
					.preparePutRepository(repo.id())//
					.setType(repo.type())//
					.setSettings(repo.settings())//
					.get();

			if (!putRepositoryResponse.isAcknowledged())
				throw Exceptions.runtime(//
						"error creating snapshot repository with id [%s]: no details available", //
						repoId);
		}

		return repoId;
	}
 

import org.elasticsearch.repositories.RepositoryMissingException; //导入依赖的package包/类
public static void wipeRepositories(String... repositories) {
    // if nothing is provided, delete all
    if (repositories.length == 0) {
        repositories = new String[]{"*"};
    }
    for (String repository : repositories) {
        try {
            client().admin().cluster().prepareDeleteRepository(repository).execute().actionGet();
        } catch (RepositoryMissingException ex) {
            // ignore
        }
    }
}