@Override

    protected ViewResponse shardOperation(ViewRequest request, int shardId) throws ElasticSearchException {

        // Get the doc first

        GetResult getResult = indexShard.getService().get(request.type(), request.id(), null, false);

        if (!getResult.exists()) {

            throw new ElasticSearchIllegalArgumentException("Document not found, cannot render view");

        }

        // when all shards are started within a shard replication group, delete an unallocated shard on this node

        RoutingTable routingTable = event.state().routingTable();

        for (IndexRoutingTable indexRoutingTable : routingTable) {

            if (indexService == null) {

                // we handle this later...

                continue;

            }

            // if the store is not persistent, don't bother trying to check if it can be deleted

                continue;

            }

            for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {

                // if it has been created on this node, we don't want to delete it

                    continue;

                }

                    continue;

                }

                // only delete an unallocated shard if all (other shards) are started

                if (indexShardRoutingTable.countWithState(ShardRoutingState.STARTED) == indexShardRoutingTable.size()) {

                    if (logger.isDebugEnabled()) {

                        logger.debug("[{}][{}] deleting unallocated shard", indexShardRoutingTable.shardId().index().name(), indexShardRoutingTable.shardId().id());

                    }

                    try {

                    } catch (Exception e) {

                        logger.debug("[{}][{}] failed to delete unallocated shard, ignoring", e, indexShardRoutingTable.shardId().index().name(), indexShardRoutingTable.shardId().id());

                    }

                }

            }

        }

        // do the reverse, and delete dangling indices / shards that might remain on that node

        // this can happen when deleting a closed index, or when a node joins and it has deleted indices / shards

        if (nodeEnv.hasNodeFile()) {

            // delete unused shards for existing indices

            for (IndexRoutingTable indexRoutingTable : routingTable) {

                if (indexService != null) { // allocated, ignore this

                    continue;

                }

                for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {

                    boolean shardCanBeDeleted = true;

        return indices.get(index);

    }

    @Override public IndexService indexServiceSafe(String index) throws IndexMissingException {

        if (indexService == null) {

            throw new IndexMissingException(new Index(index));

        }

        return indexService;

    }

        Injector indexInjector = modules.createChildInjector(injector);

        indicesInjectors.put(index.name(), indexInjector);

        indicesLifecycle.afterIndexCreated(indexService);

        indices = newMapBuilder(indices).put(index.name(), indexService).immutableMap();

    }

    private void deleteIndex(String index, boolean delete, String reason, @Nullable Executor executor) throws ElasticSearchException {

        Injector indexInjector;

        synchronized (this) {

            indexInjector = indicesInjectors.remove(index);

            if (indexInjector == null) {

                if (!delete) {

                    return;

                }

                throw new IndexMissingException(new Index(index));

            }

            if (delete) {

                logger.debug("deleting Index [{}]", index);

            }

            Map<String, IndexService> tmpMap = newHashMap(indices);

            indexService = tmpMap.remove(index);

            indices = ImmutableMap.copyOf(tmpMap);

        }

        indicesLifecycle.beforeIndexClosed(indexService, delete);

        for (Class<? extends CloseableIndexComponent> closeable : pluginsService.indexServices()) {

            indexInjector.getInstance(closeable).close(delete);

        }

        ((InternalIndexService) indexService).close(delete, reason, executor);

        indexInjector.getInstance(PercolatorService.class).close();

        indexInjector.getInstance(IndexCache.class).close();

        indexInjector.getInstance(AnalysisService.class).close();

        indexInjector.getInstance(IndexEngine.class).close();

        indexInjector.getInstance(IndexServiceManagement.class).close();

        indexInjector.getInstance(IndexGateway.class).close(delete);

        indexInjector.getInstance(MapperService.class).close();

        indexInjector.getInstance(IndexQueryParserService.class).close();

        Injectors.close(injector);

        if (delete) {

            FileSystemUtils.deleteRecursively(nodeEnv.indexLocation(new Index(index)));

        }

    }

            // are going to recover them again once state persistence is disabled (no master / not recovered)

            // TODO: this feels a bit hacky here, a block disables state persistence, and then we clean the allocated shards, maybe another flag in blocks?

            if (event.state().blocks().disableStatePersistence()) {

                for (final String index : indicesService.indices()) {

                        logger.debug("[{}][{}] removing shard (disabled block persistence)", index, shardId);

                        try {

                        } catch (Exception e) {

                            logger.warn("[{}] failed to remove shard (disabled block persistence)", e, index);

                        }

                    }

                    indicesService.cleanIndex(index, "cleaning index (disabled block persistence)");

        // so applyDeletedIndices might not take them into account

        for (final String index : indicesService.indices()) {

            IndexMetaData indexMetaData = event.state().metaData().index(index);

            if (indexMetaData != null && indexMetaData.state() == IndexMetaData.State.CLOSE) {

                    logger.debug("[{}][{}] removing shard (index is closed)", index, shardId);

                    try {

                    } catch (Exception e) {

                        logger.warn("[{}] failed to remove shard (index is closed)", e, index);

                    }

                }

            }

                    if (shardRouting.index().equals(index)) {

                        newShardIds.add(shardRouting.id());

                    }

                }

                if (indexService == null) {

                    continue;

                }

                    if (!newShardIds.contains(existingShardId)) {

                        if (indexMetaData.state() == IndexMetaData.State.CLOSE) {

                            if (logger.isDebugEnabled()) {

                                logger.debug("[{}][{}] removing shard (index is closed)", index, existingShardId);

                            }

                        } else {

                            // we can just remove the shard, without cleaning it locally, since we will clean it

                            // when all shards are allocated in the IndicesStore

                            if (logger.isDebugEnabled()) {

                                logger.debug("[{}][{}] removing shard (not allocated)", index, existingShardId);

                            }

                        }

                    }

                }

            }

        }

                // we only create / update here

                continue;

            }

            String index = indexMetaData.index();

            indexSettingsService.refreshSettings(indexMetaData.settings());

        }

    }

                continue;

            }

            List<String> typesToRefresh = null;

            String index = indexMetaData.index();

            // first, go over and update the _default_ mapping (if exists)

            if (indexMetaData.mappings().containsKey(MapperService.DEFAULT_MAPPING)) {

                processMapping(event, index, mapperService, MapperService.DEFAULT_MAPPING, indexMetaData.mapping(MapperService.DEFAULT_MAPPING).source());

            }