runner.refresh();

        GetResponse getResponse =
                runner.client().prepareGet().setIndex(suggester.getIndex()).setId(item.getId()).get(TimeValue.timeValueSeconds(30));
        assertTrue(getResponse.isExists());
    }

    @Test
    public void test_writeItemsWithUpdate() throws Exception {
        String[][] readings = new String[1][];
        readings[0] = new String[] { "test" };

        try {
            final GetResponse getResponse =
                    client.prepareGet().setIndex(settingsIndexName).setId(settingsId).execute().actionGet(getSearchTimeout());

            if (!getResponse.isExists()) {
                doCreate = true;
            }
        } catch (final IndexNotFoundException e) {
            doIndexCreate = true;
            doCreate = true;
        }

        if (doCreate) {

        for (final SuggestItem item : mergedItems) {
            final GetResponse getResponse = client.prepareGet().setIndex(index).setId(item.getId()).get(settings.getIndexTimeout());
            if (update && getResponse.isExists()) {
                final IndexRequestBuilder indexRequestBuilder = new IndexRequestBuilder(client, IndexAction.INSTANCE, index);
                indexRequestBuilder.setId(item.getId())

            log.trace("Using cached attributes (expires in {}ms)", this.attrExpiration - currentTime);
            return this.isExists;
        }

        // Fast path for already resolved existence with recent cache
        if (this.isExists && (currentTime - (this.attrExpiration - getContext().getConfig().getAttributeCacheTimeout())) < 5000) {
            log.trace("Using recent positive existence cache");

    public boolean exists() throws SmbException {

        if (attrExpiration > System.currentTimeMillis()) {
            return isExists;
        }

        attributes = ATTR_READONLY | ATTR_DIRECTORY;
        createTime = 0L;
        lastModified = 0L;
        isExists = false;

        try {
            if (url.getHost().length() == 0) {} else if (share == null) {

            final IndicesExistsResponse response =
                    client.admin().indices().prepareExists(getSearchAlias(index)).execute().actionGet(suggestSettings.getIndicesTimeout());
            if (!response.isExists()) {
                final String mappingSource = getDefaultMappings();
                final String settingsSource = getDefaultIndexSettings();
                final String indexName = createIndexName(index);

        boolean exists = false;
        try {
            final IndicesExistsResponse response = fesenClient.get(c -> c.admin().indices().prepareExists(index).execute());
            exists = response.isExists();
        } catch (final IndexNotFoundException e) {
            // ignore
        }
        if (!exists) {
            final CreateIndexResponse indexResponse = fesenClient.get(c -> {

        try {
            final IndicesExistsResponse response =
                    client.admin().indices().prepareExists(analyzerSettingsIndexName).execute().actionGet(settings.getIndicesTimeout());
            if (!response.isExists()) {
                createAnalyzerSettings(loadIndexSettings(), loadIndexMapping());
            }
            analyzerMap.put(analyzerSettingsIndexName, getAnalyzerNames());

        try {
            final IndicesExistsResponse response =
                    client.admin().indices().prepareExists(indexName).execute().actionGet(fessConfig.getIndexSearchTimeout());
            exists = response.isExists();
        } catch (final Exception e) {
            logger.debug("Failed to check index status: indexName={}", indexName, e);
        }
        return exists;
    }

    /**

    }

    /**
     * @throws Exception
     */
    public void testIsExist() throws Exception {
        assertEquals("1", true, ResourceUtil.isExist("CLMessages.properties"));
        assertEquals("2", false, ResourceUtil.isExist("hoge"));
    }

    /**
     * @throws Exception
     */
    public void testGetExtension() throws Exception {