io.kubernetes.client.informer.SharedIndexInformer Java Examples

private SharedIndexInformer<V1Pod> createPodInformer(SharedInformerFactory sharedInformerFactory) {
    return sharedInformerFactory.sharedIndexInformerFor(
            (CallGeneratorParams params) -> coreV1Api.listNamespacedPodCall(
                    KUBERNETES_NAMESPACE,
                    null,
                    null,
                    null,
                    null,
                    null,
                    null,
                    params.resourceVersion,
                    params.timeoutSeconds,
                    params.watch,
                    null
            ),
            V1Pod.class,
            V1PodList.class,
            configuration.getKubeApiServerIntegratorRefreshIntervalMs()
    );
}
 

public KubeInformerMetrics(String type,
                           SharedIndexInformer<ApiType> informer,
                           TitusRuntime titusRuntime) {
    this.titusRuntime = titusRuntime;
    this.sizeGaugeId = titusRuntime.getRegistry().createId(METRICS_INFORMER, "type", type);
    this.syncedGaugeId = titusRuntime.getRegistry().createId(METRICS_INFORMER_SYNCED, "type", type);
    this.stalenessGaugeId = titusRuntime.getRegistry().createId(METRICS_INFORMER_STALENESS, "type", type);

    PolledMeter.using(titusRuntime.getRegistry())
            .withId(sizeGaugeId)
            .monitorValue(informer, i -> i.getIndexer().list().size());
    PolledMeter.using(titusRuntime.getRegistry())
            .withId(syncedGaugeId)
            .monitorValue(informer, i -> i.hasSynced() ? 1 : 0);
    PolledMeter.using(titusRuntime.getRegistry())
            .withId(stalenessGaugeId)
            .monitorValue(informer, i -> informer.hasSynced() ? 0 : -1);
}
 

private SharedIndexInformer<V1Node> createNodeInformer(SharedInformerFactory sharedInformerFactory) {
    return sharedInformerFactory.sharedIndexInformerFor(
            (CallGeneratorParams params) -> coreV1Api.listNodeCall(
                    null,
                    null,
                    null,
                    null,
                    null,
                    null,
                    params.resourceVersion,
                    params.timeoutSeconds,
                    params.watch,
                    null
            ),
            V1Node.class,
            V1NodeList.class,
            configuration.getKubeApiServerIntegratorRefreshIntervalMs()
    );
}
 

private KubeApiFacade createKubeApiFacade() {
    Indexer<V1Node> indexer = mock(Indexer.class);
    SharedIndexInformer<V1Node> nodeInformer = mock(SharedIndexInformer.class);
    KubeApiFacade kubeApiFacade = mock(KubeApiFacade.class);

    when(kubeApiFacade.getNodeInformer()).thenReturn(nodeInformer);
    when(nodeInformer.getIndexer()).thenReturn(indexer);

    return kubeApiFacade;
}
 

public FitSharedIndexInformer(String id,
                              SharedIndexInformer<T> source,
                              TitusRuntime titusRuntime) {
    this.source = source;

    FitFramework fit = titusRuntime.getFitFramework();
    this.fitKubeInjection = fit.newFitInjectionBuilder(id)
            .withDescription("SharedIndexInformer FIT injection for " + id)
            .build();
    fit.getRootComponent().getChild(DirectKubeApiServerIntegrator.COMPONENT).addInjection(fitKubeInjection);
}
 

private SharedIndexInformer<V1OpportunisticResource> createOpportunisticResourceInformer(SharedInformerFactory sharedInformerFactory) {
    return sharedInformerFactory.sharedIndexInformerFor(
            this::listOpportunisticResourcesCall,
            V1OpportunisticResource.class,
            V1OpportunisticResourceList.class,
            configuration.getKubeOpportunisticRefreshIntervalMs()
    );
}
 

@Override
public SharedIndexInformer<V1Pod> getPodInformer() {
    activate();
    return podInformer;
}
 

@Override
public SharedIndexInformer<V1OpportunisticResource> getOpportunisticResourceInformer() {
    activate();
    return opportunisticResourceInformer;
}
 

@Override
public SharedIndexInformer<V1Node> getNodeInformer() {
    activate();
    return nodeInformer;
}
 

@Test
public void testInformerReListingOnListForbidden() throws InterruptedException {

  CoreV1Api coreV1Api = new CoreV1Api(client);

  stubFor(
      get(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("false"))
          .willReturn(
              aResponse()
                  .withStatus(403)
                  .withHeader("Content-Type", "application/json")
                  .withBody(
                      new JSON()
                          .serialize(
                              new V1Status()
                                  .apiVersion("v1")
                                  .kind("Status")
                                  .code(403)
                                  .reason("RBAC forbidden")))));

  SharedInformerFactory factory = new SharedInformerFactory();
  SharedIndexInformer<V1Pod> podInformer =
      factory.sharedIndexInformerFor(
          (CallGeneratorParams params) -> {
            try {
              return coreV1Api.listNamespacedPodCall(
                  namespace,
                  null,
                  null,
                  null,
                  null,
                  null,
                  null,
                  params.resourceVersion,
                  params.timeoutSeconds,
                  params.watch,
                  null);
            } catch (ApiException e) {
              throw new RuntimeException(e);
            }
          },
          V1Pod.class,
          V1PodList.class);

  factory.startAllRegisteredInformers();

  // Sleep mroe than 1s so that informer can perform multiple rounds of list-watch
  Thread.sleep(3000);

  verify(
      moreThan(1),
      getRequestedFor(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("false")));
  factory.stopAllRegisteredInformers();
}
 

@Test
public void testInformerReListWatchOnWatchConflict() throws InterruptedException {

  CoreV1Api coreV1Api = new CoreV1Api(client);

  String startRV = "1000";
  V1PodList podList =
      new V1PodList().metadata(new V1ListMeta().resourceVersion(startRV)).items(Arrays.asList());

  stubFor(
      get(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("false"))
          .willReturn(
              aResponse()
                  .withStatus(200)
                  .withHeader("Content-Type", "application/json")
                  .withBody(new JSON().serialize(podList))));

  Watch.Response<V1Pod> watchResponse =
      new Watch.Response<>(
          EventType.ERROR.name(), new V1Status().apiVersion("v1").kind("Status").code(409));
  stubFor(
      get(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("true"))
          .withQueryParam("resourceVersion", equalTo(startRV))
          .willReturn(
              aResponse()
                  .withStatus(200)
                  .withHeader("Content-Type", "application/json")
                  .withBody(new JSON().serialize(watchResponse))));

  SharedInformerFactory factory = new SharedInformerFactory();
  SharedIndexInformer<V1Pod> podInformer =
      factory.sharedIndexInformerFor(
          (CallGeneratorParams params) -> {
            try {
              return coreV1Api.listNamespacedPodCall(
                  namespace,
                  null,
                  null,
                  null,
                  null,
                  null,
                  null,
                  params.resourceVersion,
                  params.timeoutSeconds,
                  params.watch,
                  null);
            } catch (ApiException e) {
              throw new RuntimeException(e);
            }
          },
          V1Pod.class,
          V1PodList.class);

  factory.startAllRegisteredInformers();

  // Sleep mroe than 1s so that informer can perform multiple rounds of list-watch
  Thread.sleep(3000);

  verify(
      moreThan(1),
      getRequestedFor(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("false")));
  verify(
      moreThan(1),
      getRequestedFor(urlPathEqualTo("/api/v1/namespaces/" + namespace + "/pods"))
          .withQueryParam("watch", equalTo("true")));
  factory.stopAllRegisteredInformers();
}
 

@Override
public SharedIndexInformer<V1Node> getNodeInformer() {
    throw new IllegalStateException("Kubernetes not supported");
}
 

@Override
public SharedIndexInformer<V1Pod> getPodInformer() {
    throw new IllegalStateException("Kubernetes not supported");
}
 

@Override
public SharedIndexInformer<V1OpportunisticResource> getOpportunisticResourceInformer() {
    throw new IllegalStateException("Kubernetes not supported");
}
 

public NodePrintingReconciler(
    SharedIndexInformer<V1Node> nodeInformer, EventRecorder recorder) {
  this.nodeLister = new Lister<>(nodeInformer.getIndexer());
  this.eventRecorder = recorder;
}
 

public static void main(String[] args) throws IOException {

    CoreV1Api coreV1Api = new CoreV1Api();
    ApiClient apiClient = coreV1Api.getApiClient();
    OkHttpClient httpClient =
        apiClient.getHttpClient().newBuilder().readTimeout(0, TimeUnit.SECONDS).build();
    apiClient.setHttpClient(httpClient);

    // instantiating an informer-factory, and there should be only one informer-factory globally.
    SharedInformerFactory informerFactory = new SharedInformerFactory();
    // registering node-informer into the informer-factory.
    SharedIndexInformer<V1Node> nodeInformer =
        informerFactory.sharedIndexInformerFor(
            (CallGeneratorParams params) -> {
              return coreV1Api.listNodeCall(
                  null,
                  null,
                  null,
                  null,
                  null,
                  null,
                  params.resourceVersion,
                  params.timeoutSeconds,
                  params.watch,
                  null);
            },
            V1Node.class,
            V1NodeList.class);
    informerFactory.startAllRegisteredInformers();

    EventBroadcaster eventBroadcaster = new LegacyEventBroadcaster(coreV1Api);

    // nodeReconciler prints node information on events
    NodePrintingReconciler nodeReconciler =
        new NodePrintingReconciler(
            nodeInformer,
            eventBroadcaster.newRecorder(
                new V1EventSource().host("localhost").component("node-printer")));

    // Use builder library to construct a default controller.
    Controller controller =
        ControllerBuilder.defaultBuilder(informerFactory)
            .watch(
                (workQueue) ->
                    ControllerBuilder.controllerWatchBuilder(V1Node.class, workQueue)
                        .withWorkQueueKeyFunc(
                            (V1Node node) ->
                                new Request(node.getMetadata().getName())) // optional, default to
                        .withOnAddFilter(
                            (V1Node createdNode) ->
                                createdNode
                                    .getMetadata()
                                    .getName()
                                    .startsWith("docker-")) // optional, set onAdd filter
                        .withOnUpdateFilter(
                            (V1Node oldNode, V1Node newNode) ->
                                newNode
                                    .getMetadata()
                                    .getName()
                                    .startsWith("docker-")) // optional, set onUpdate filter
                        .withOnDeleteFilter(
                            (V1Node deletedNode, Boolean stateUnknown) ->
                                deletedNode
                                    .getMetadata()
                                    .getName()
                                    .startsWith("docker-")) // optional, set onDelete filter
                        .build())
            .withReconciler(nodeReconciler) // required, set the actual reconciler
            .withName("node-printing-controller") // optional, set name for controller
            .withWorkerCount(4) // optional, set worker thread count
            .withReadyFunc(
                nodeInformer
                    ::hasSynced) // optional, only starts controller when the cache has synced up
            .build();

    // Use builder library to manage one or multiple controllers.
    ControllerManager controllerManager =
        ControllerBuilder.controllerManagerBuilder(informerFactory)
            .addController(controller)
            .build();

    LeaderElectingController leaderElectingController =
        new LeaderElectingController(
            new LeaderElector(
                new LeaderElectionConfig(
                    new EndpointsLock("kube-system", "leader-election", "foo"),
                    Duration.ofMillis(10000),
                    Duration.ofMillis(8000),
                    Duration.ofMillis(5000))),
            controllerManager);

    leaderElectingController.run();
  }
 

SharedIndexInformer<V1Node> getNodeInformer(); 

SharedIndexInformer<V1Pod> getPodInformer(); 

SharedIndexInformer<V1OpportunisticResource> getOpportunisticResourceInformer();