src/main/java/com/google/gerrit/opensearch/RestClientProvider.java

// Copyright (C) 2026 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.opensearch;

import com.google.common.flogger.FluentLogger;
import com.google.gerrit.extensions.events.LifecycleListener;
import com.google.gerrit.lifecycle.LifecycleModule;
import com.google.gson.JsonParser;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.Singleton;
import java.io.IOException;
import org.apache.hc.client5.http.auth.AuthScope;
import org.apache.hc.client5.http.auth.UsernamePasswordCredentials;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.async.HttpAsyncClientBuilder;
import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.Header;
import org.apache.hc.core5.http.HttpStatus;
import org.apache.hc.core5.http.message.BasicHeader;
import org.apache.hc.core5.http.message.StatusLine;
import org.apache.hc.core5.util.Timeout;
import org.opensearch.client.Request;
import org.opensearch.client.Response;
import org.opensearch.client.RestClient;
import org.opensearch.client.RestClientBuilder;

@Singleton
class RestClientProvider implements Provider<RestClient>, LifecycleListener {
  private static final FluentLogger logger = FluentLogger.forEnclosingClass();

  private final OpenSearchConfiguration cfg;

  private volatile RestClient client;
  private QueryAdapter adapter;

  @Inject
  RestClientProvider(OpenSearchConfiguration cfg) {
    this.cfg = cfg;
  }

  public static LifecycleModule module() {
    return new LifecycleModule() {
      @Override
      protected void configure() {
        listener().to(RestClientProvider.class);
      }
    };
  }

  @Override
  public RestClient get() {
    if (client == null) {
      synchronized (this) {
        if (client == null) {
          client = build();
          OpenSearchVersion version = getVersion();
          logger.atInfo().log("OpenSearch integration version %s", version);
          adapter = new QueryAdapter();
        }
      }
    }
    return client;
  }

  @Override
  public void start() {}

  @Override
  public void stop() {
    if (client != null) {
      try {
        client.close();
      } catch (IOException e) {
        // Ignore. We can't do anything about it.
      }
    }
  }

  QueryAdapter adapter() {
    get(); // Make sure we're connected
    return adapter;
  }

  public static class FailedToGetVersion extends OpenSearchException {
    private static final long serialVersionUID = 1L;
    private static final String MESSAGE = "Failed to get OpenSearch version";

    FailedToGetVersion(StatusLine status) {
      super(String.format("%s: %d %s", MESSAGE, status.getStatusCode(), status.getReasonPhrase()));
    }

    FailedToGetVersion(Throwable cause) {
      super(MESSAGE, cause);
    }
  }

  private OpenSearchVersion getVersion() throws OpenSearchException {
    try {
      Response response = client.performRequest(new Request("GET", "/"));
      StatusLine statusLine = response.getStatusLine();
      if (statusLine.getStatusCode() != HttpStatus.SC_OK) {
        throw new FailedToGetVersion(statusLine);
      }
      String version =
          JsonParser.parseString(AbstractOpenSearchIndex.getContent(response))
              .getAsJsonObject()
              .get("version")
              .getAsJsonObject()
              .get("number")
              .getAsString();
      logger.atInfo().log("Connected to OpenSearch version %s", version);
      return OpenSearchVersion.forVersion(version);
    } catch (IOException e) {
      throw new FailedToGetVersion(e);
    }
  }

  private RestClient build() {
    RestClientBuilder builder = RestClient.builder(cfg.getHosts());
    builder.setDefaultHeaders(
        new Header[] {new BasicHeader("Accept", ContentType.APPLICATION_JSON.toString())});
    setConfiguredTimeouts(builder);
    setConfiguredCredentialsIfAny(builder);
    return builder.build();
  }

  private void setConfiguredTimeouts(RestClientBuilder builder) {
    builder.setRequestConfigCallback(
        (RequestConfig.Builder requestConfigBuilder) ->
            requestConfigBuilder
                .setConnectTimeout(Timeout.ofMilliseconds(cfg.connectTimeout))
                .setResponseTimeout(Timeout.ofMilliseconds(cfg.socketTimeout)));
  }

  private void setConfiguredCredentialsIfAny(RestClientBuilder builder) {
    String username = cfg.username;
    String password = cfg.password;
    if (username != null && password != null) {
      BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
      credentialsProvider.setCredentials(
          new AuthScope(null, -1),
          new UsernamePasswordCredentials(username, password.toCharArray()));
      builder.setHttpClientConfigCallback(
          (HttpAsyncClientBuilder httpClientBuilder) -> {
            httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            configureHttpClientBuilder(httpClientBuilder);
            return httpClientBuilder;
          });
    }
  }

  protected void configureHttpClientBuilder(
      @SuppressWarnings("unused") HttpAsyncClientBuilder httpClientBuilder) {}
}