예제 #1
0
    @Override
    protected void configure() {
      IndexShard shard = mock(IndexShard.class);
      bind(IndexShard.class).toInstance(shard);
      when(shard.shardId()).thenReturn(shardId);
      Index index = new Index(TEST_TABLE_NAME);
      bind(Index.class).toInstance(index);
      bind(ShardId.class).toInstance(shardId);
      MapBinder<ReferenceIdent, ShardReferenceImplementation> binder =
          MapBinder.newMapBinder(
              binder(), ReferenceIdent.class, ShardReferenceImplementation.class);
      binder
          .addBinding(SysShardsTableInfo.INFOS.get(new ColumnIdent("id")).ident())
          .toInstance(shardIdExpression);
      bind(ShardReferenceResolver.class).asEagerSingleton();
      bind(AllocationDecider.class).to(DiskThresholdDecider.class);
      bind(ShardCollectService.class).asEagerSingleton();

      bind(DiscoveryService.class).toInstance(discoveryService);

      // blob stuff
      MapBinder<ReferenceIdent, BlobShardReferenceImplementation> blobBinder =
          MapBinder.newMapBinder(
              binder(), ReferenceIdent.class, BlobShardReferenceImplementation.class);
      bind(Settings.class).annotatedWith(IndexSettings.class).toInstance(ImmutableSettings.EMPTY);
    }
예제 #2
0
 @Override
 protected void bindExtensions(Binder binder) {
   MapBinder<K, V> mapBinder = MapBinder.newMapBinder(binder, keyType, valueType);
   for (Map.Entry<K, V> entry : map.entrySet()) {
     mapBinder.addBinding(entry.getKey()).toInstance(entry.getValue());
   }
 }
예제 #3
0
 @Override
 protected final void bindExtensions(Binder binder) {
   MapBinder<String, T> parserMapBinder =
       MapBinder.newMapBinder(binder, String.class, extensionClass);
   for (Map.Entry<String, Class<? extends T>> clazz : extensions.entrySet()) {
     parserMapBinder.addBinding(clazz.getKey()).to(clazz.getValue());
   }
 }
 public void processXContentQueryParser(
     String name, Class<? extends QueryParser> xcontentQueryParser) {
   if (!groupSettings.containsKey(name)) {
     binder
         .addBinding(name)
         .toProvider(FactoryProvider.newFactory(QueryParserFactory.class, xcontentQueryParser))
         .in(Scopes.SINGLETON);
   }
 }
예제 #5
0
  @Override
  protected void configure() {

    registerAction(NodesInfoAction.INSTANCE, TransportNodesInfoAction.class);
    registerAction(NodesStatsAction.INSTANCE, TransportNodesStatsAction.class);
    registerAction(NodesShutdownAction.INSTANCE, TransportNodesShutdownAction.class);
    registerAction(NodesRestartAction.INSTANCE, TransportNodesRestartAction.class);
    registerAction(NodesHotThreadsAction.INSTANCE, TransportNodesHotThreadsAction.class);

    registerAction(ClusterStateAction.INSTANCE, TransportClusterStateAction.class);
    registerAction(ClusterHealthAction.INSTANCE, TransportClusterHealthAction.class);
    registerAction(
        ClusterUpdateSettingsAction.INSTANCE, TransportClusterUpdateSettingsAction.class);
    registerAction(ClusterRerouteAction.INSTANCE, TransportClusterRerouteAction.class);
    registerAction(ClusterSearchShardsAction.INSTANCE, TransportClusterSearchShardsAction.class);
    registerAction(PendingClusterTasksAction.INSTANCE, TransportPendingClusterTasksAction.class);

    registerAction(IndicesStatsAction.INSTANCE, TransportIndicesStatsAction.class);
    registerAction(IndicesStatusAction.INSTANCE, TransportIndicesStatusAction.class);
    registerAction(IndicesSegmentsAction.INSTANCE, TransportIndicesSegmentsAction.class);
    registerAction(CreateIndexAction.INSTANCE, TransportCreateIndexAction.class);
    registerAction(DeleteIndexAction.INSTANCE, TransportDeleteIndexAction.class);
    registerAction(OpenIndexAction.INSTANCE, TransportOpenIndexAction.class);
    registerAction(CloseIndexAction.INSTANCE, TransportCloseIndexAction.class);
    registerAction(IndicesExistsAction.INSTANCE, TransportIndicesExistsAction.class);
    registerAction(TypesExistsAction.INSTANCE, TransportTypesExistsAction.class);
    registerAction(GetMappingsAction.INSTANCE, TransportGetMappingsAction.class);
    registerAction(GetFieldMappingsAction.INSTANCE, TransportGetFieldMappingsAction.class);
    registerAction(PutMappingAction.INSTANCE, TransportPutMappingAction.class);
    registerAction(DeleteMappingAction.INSTANCE, TransportDeleteMappingAction.class);
    registerAction(IndicesAliasesAction.INSTANCE, TransportIndicesAliasesAction.class);
    registerAction(UpdateSettingsAction.INSTANCE, TransportUpdateSettingsAction.class);
    registerAction(AnalyzeAction.INSTANCE, TransportAnalyzeAction.class);
    registerAction(PutIndexTemplateAction.INSTANCE, TransportPutIndexTemplateAction.class);
    registerAction(GetIndexTemplatesAction.INSTANCE, TransportGetIndexTemplatesAction.class);
    registerAction(DeleteIndexTemplateAction.INSTANCE, TransportDeleteIndexTemplateAction.class);
    registerAction(ValidateQueryAction.INSTANCE, TransportValidateQueryAction.class);
    registerAction(GatewaySnapshotAction.INSTANCE, TransportGatewaySnapshotAction.class);
    registerAction(RefreshAction.INSTANCE, TransportRefreshAction.class);
    registerAction(FlushAction.INSTANCE, TransportFlushAction.class);
    registerAction(OptimizeAction.INSTANCE, TransportOptimizeAction.class);
    registerAction(ClearIndicesCacheAction.INSTANCE, TransportClearIndicesCacheAction.class);
    registerAction(PutWarmerAction.INSTANCE, TransportPutWarmerAction.class);
    registerAction(DeleteWarmerAction.INSTANCE, TransportDeleteWarmerAction.class);
    registerAction(GetWarmersAction.INSTANCE, TransportGetWarmersAction.class);
    registerAction(GetAliasesAction.INSTANCE, TransportGetAliasesAction.class);
    registerAction(AliasesExistAction.INSTANCE, TransportAliasesExistAction.class);

    registerAction(IndexAction.INSTANCE, TransportIndexAction.class);
    registerAction(GetAction.INSTANCE, TransportGetAction.class);
    registerAction(TermVectorAction.INSTANCE, TransportSingleShardTermVectorAction.class);
    registerAction(
        MultiTermVectorsAction.INSTANCE,
        TransportMultiTermVectorsAction.class,
        TransportSingleShardMultiTermsVectorAction.class);
    registerAction(
        DeleteAction.INSTANCE,
        TransportDeleteAction.class,
        TransportIndexDeleteAction.class,
        TransportShardDeleteAction.class);
    registerAction(CountAction.INSTANCE, TransportCountAction.class);
    registerAction(SuggestAction.INSTANCE, TransportSuggestAction.class);
    registerAction(UpdateAction.INSTANCE, TransportUpdateAction.class);
    registerAction(
        MultiGetAction.INSTANCE, TransportMultiGetAction.class, TransportShardMultiGetAction.class);
    registerAction(BulkAction.INSTANCE, TransportBulkAction.class, TransportShardBulkAction.class);
    registerAction(
        DeleteByQueryAction.INSTANCE,
        TransportDeleteByQueryAction.class,
        TransportIndexDeleteByQueryAction.class,
        TransportShardDeleteByQueryAction.class);
    registerAction(
        SearchAction.INSTANCE,
        TransportSearchAction.class,
        TransportSearchDfsQueryThenFetchAction.class,
        TransportSearchQueryThenFetchAction.class,
        TransportSearchDfsQueryAndFetchAction.class,
        TransportSearchQueryAndFetchAction.class,
        TransportSearchScanAction.class);
    registerAction(
        SearchScrollAction.INSTANCE,
        TransportSearchScrollAction.class,
        TransportSearchScrollScanAction.class,
        TransportSearchScrollQueryThenFetchAction.class,
        TransportSearchScrollQueryAndFetchAction.class);
    registerAction(MultiSearchAction.INSTANCE, TransportMultiSearchAction.class);
    registerAction(MoreLikeThisAction.INSTANCE, TransportMoreLikeThisAction.class);
    registerAction(PercolateAction.INSTANCE, TransportPercolateAction.class);
    registerAction(
        MultiPercolateAction.INSTANCE,
        TransportMultiPercolateAction.class,
        TransportShardMultiPercolateAction.class);
    registerAction(ExplainAction.INSTANCE, TransportExplainAction.class);
    registerAction(ClearScrollAction.INSTANCE, TransportClearScrollAction.class);

    // register Name -> GenericAction Map that can be injected to instances.
    MapBinder<String, GenericAction> actionsBinder =
        MapBinder.newMapBinder(binder(), String.class, GenericAction.class);

    for (Map.Entry<String, ActionEntry> entry : actions.entrySet()) {
      actionsBinder.addBinding(entry.getKey()).toInstance(entry.getValue().action);
    }

    // register GenericAction -> transportAction Map that can be injected to instances.
    // also register any supporting classes
    if (!proxy) {
      MapBinder<GenericAction, TransportAction> transportActionsBinder =
          MapBinder.newMapBinder(binder(), GenericAction.class, TransportAction.class);
      for (Map.Entry<String, ActionEntry> entry : actions.entrySet()) {
        // bind the action as eager singleton, so the map binder one will reuse it
        bind(entry.getValue().transportAction).asEagerSingleton();
        transportActionsBinder
            .addBinding(entry.getValue().action)
            .to(entry.getValue().transportAction)
            .asEagerSingleton();
        for (Class supportAction : entry.getValue().supportTransportActions) {
          bind(supportAction).asEagerSingleton();
        }
      }
    }
  }
예제 #6
0
    @Override
    protected void configure() {
      functionBinder =
          MapBinder.newMapBinder(binder(), FunctionIdent.class, FunctionImplementation.class);
      functionBinder.addBinding(TestFunction.ident).toInstance(new TestFunction());
      bind(Functions.class).asEagerSingleton();
      bind(ReferenceInfos.class).toInstance(mock(ReferenceInfos.class));
      bind(ThreadPool.class).toInstance(testThreadPool);

      BulkRetryCoordinator bulkRetryCoordinator = mock(BulkRetryCoordinator.class);
      BulkRetryCoordinatorPool bulkRetryCoordinatorPool = mock(BulkRetryCoordinatorPool.class);
      when(bulkRetryCoordinatorPool.coordinator(any(ShardId.class)))
          .thenReturn(bulkRetryCoordinator);
      bind(BulkRetryCoordinatorPool.class).toInstance(bulkRetryCoordinatorPool);

      bind(TransportBulkCreateIndicesAction.class)
          .toInstance(mock(TransportBulkCreateIndicesAction.class));
      bind(CircuitBreakerService.class).toInstance(new NoneCircuitBreakerService());
      bind(ActionFilters.class).toInstance(mock(ActionFilters.class));
      bind(ScriptService.class).toInstance(mock(ScriptService.class));
      bind(SearchService.class).toInstance(mock(InternalSearchService.class));
      bind(AllocationService.class).toInstance(mock(AllocationService.class));
      bind(MetaDataCreateIndexService.class).toInstance(mock(MetaDataCreateIndexService.class));
      bind(DynamicSettings.class)
          .annotatedWith(ClusterDynamicSettings.class)
          .toInstance(mock(DynamicSettings.class));
      bind(MetaDataDeleteIndexService.class).toInstance(mock(MetaDataDeleteIndexService.class));
      bind(ClusterInfoService.class).toInstance(mock(ClusterInfoService.class));
      bind(TransportService.class).toInstance(mock(TransportService.class));
      bind(MapperService.class).toInstance(mock(MapperService.class));

      OsService osService = mock(OsService.class);
      OsStats osStats = mock(OsStats.class);
      when(osService.stats()).thenReturn(osStats);
      OsStats.Cpu osCpu = mock(OsStats.Cpu.class);
      when(osCpu.stolen()).thenReturn((short) 1);
      when(osStats.cpu()).thenReturn(osCpu);

      bind(OsService.class).toInstance(osService);
      bind(NodeService.class).toInstance(mock(NodeService.class));
      bind(Discovery.class).toInstance(mock(Discovery.class));
      bind(NetworkService.class).toInstance(mock(NetworkService.class));

      bind(TransportShardBulkAction.class).toInstance(mock(TransportShardBulkAction.class));
      bind(TransportCreateIndexAction.class).toInstance(mock(TransportCreateIndexAction.class));

      discoveryService = mock(DiscoveryService.class);
      DiscoveryNode discoveryNode = mock(DiscoveryNode.class);
      when(discoveryNode.id()).thenReturn(TEST_NODE_ID);
      when(discoveryService.localNode()).thenReturn(discoveryNode);

      ClusterService clusterService = mock(ClusterService.class);
      ClusterState state = mock(ClusterState.class);
      DiscoveryNodes discoveryNodes = mock(DiscoveryNodes.class);
      when(discoveryNodes.localNodeId()).thenReturn(TEST_NODE_ID);
      when(state.nodes()).thenReturn(discoveryNodes);
      when(clusterService.state()).thenReturn(state);
      when(clusterService.localNode()).thenReturn(discoveryNode);
      bind(ClusterService.class).toInstance(clusterService);

      IndicesService indicesService = mock(IndicesService.class);
      bind(IndicesService.class).toInstance(indicesService);
      bind(Settings.class).toInstance(ImmutableSettings.EMPTY);

      bind(MetaDataUpdateSettingsService.class)
          .toInstance(mock(MetaDataUpdateSettingsService.class));
      bind(Client.class).toInstance(mock(Client.class));

      Provider<TransportCreateIndexAction> transportCreateIndexActionProvider =
          mock(Provider.class);
      when(transportCreateIndexActionProvider.get())
          .thenReturn(mock(TransportCreateIndexAction.class));
      Provider<TransportDeleteIndexAction> transportDeleteActionProvider = mock(Provider.class);
      when(transportDeleteActionProvider.get()).thenReturn(mock(TransportDeleteIndexAction.class));
      Provider<TransportUpdateSettingsAction> transportUpdateSettingsActionProvider =
          mock(Provider.class);
      when(transportUpdateSettingsActionProvider.get())
          .thenReturn(mock(TransportUpdateSettingsAction.class));

      BlobIndices blobIndices =
          new BlobIndices(
              ImmutableSettings.EMPTY,
              transportCreateIndexActionProvider,
              transportDeleteActionProvider,
              transportUpdateSettingsActionProvider,
              indicesService,
              mock(IndicesLifecycle.class),
              mock(BlobEnvironment.class),
              clusterService);
      bind(BlobIndices.class).toInstance(blobIndices);

      bind(ReferenceResolver.class).to(GlobalReferenceResolver.class);

      TransportPutIndexTemplateAction transportPutIndexTemplateAction =
          mock(TransportPutIndexTemplateAction.class);
      bind(TransportPutIndexTemplateAction.class).toInstance(transportPutIndexTemplateAction);

      bind(IndexService.class).toInstance(indexService);
    }
  @Override
  protected void configure() {

    bind(IndexQueryParserService.class).asEagerSingleton();

    // handle XContenQueryParsers
    MapBinder<String, QueryParserFactory> queryBinder =
        MapBinder.newMapBinder(binder(), String.class, QueryParserFactory.class);
    Map<String, Settings> xContentQueryParserGroups =
        settings.getGroups(IndexQueryParserService.Defaults.QUERY_PREFIX);
    for (Map.Entry<String, Settings> entry : xContentQueryParserGroups.entrySet()) {
      String qName = entry.getKey();
      Settings qSettings = entry.getValue();
      Class<? extends QueryParser> type = qSettings.getAsClass("type", null);
      if (type == null) {
        throw new IllegalArgumentException(
            "Query Parser [" + qName + "] must be provided with a type");
      }
      queryBinder
          .addBinding(qName)
          .toProvider(
              FactoryProvider.newFactory(
                  QueryParserFactory.class, qSettings.getAsClass("type", null)))
          .in(Scopes.SINGLETON);
    }

    QueryParsersProcessor.XContentQueryParsersBindings xContentQueryParsersBindings =
        new QueryParsersProcessor.XContentQueryParsersBindings(
            queryBinder, xContentQueryParserGroups);
    for (QueryParsersProcessor processor : processors) {
      processor.processXContentQueryParsers(xContentQueryParsersBindings);
    }

    for (Map.Entry<String, Class<? extends QueryParser>> entry : queries.entrySet()) {
      queryBinder
          .addBinding(entry.getKey())
          .toProvider(FactoryProvider.newFactory(QueryParserFactory.class, entry.getValue()))
          .in(Scopes.SINGLETON);
    }

    // handle XContentFilterParsers
    MapBinder<String, FilterParserFactory> filterBinder =
        MapBinder.newMapBinder(binder(), String.class, FilterParserFactory.class);
    Map<String, Settings> xContentFilterParserGroups =
        settings.getGroups(IndexQueryParserService.Defaults.FILTER_PREFIX);
    for (Map.Entry<String, Settings> entry : xContentFilterParserGroups.entrySet()) {
      String fName = entry.getKey();
      Settings fSettings = entry.getValue();
      Class<? extends FilterParser> type = fSettings.getAsClass("type", null);
      if (type == null) {
        throw new IllegalArgumentException(
            "Filter Parser [" + fName + "] must be provided with a type");
      }
      filterBinder
          .addBinding(fName)
          .toProvider(
              FactoryProvider.newFactory(
                  FilterParserFactory.class, fSettings.getAsClass("type", null)))
          .in(Scopes.SINGLETON);
    }

    QueryParsersProcessor.XContentFilterParsersBindings xContentFilterParsersBindings =
        new QueryParsersProcessor.XContentFilterParsersBindings(
            filterBinder, xContentFilterParserGroups);
    for (QueryParsersProcessor processor : processors) {
      processor.processXContentFilterParsers(xContentFilterParsersBindings);
    }

    for (Map.Entry<String, Class<? extends FilterParser>> entry : filters.entrySet()) {
      filterBinder
          .addBinding(entry.getKey())
          .toProvider(FactoryProvider.newFactory(FilterParserFactory.class, entry.getValue()))
          .in(Scopes.SINGLETON);
    }
  }