return toStorageErr(err)
}

func (client remotePeerS3Client) GetHost() string {
	return client.node.Host
}

func (client remotePeerS3Client) GetPools() []int {
	return client.pools
}

func (client *remotePeerS3Client) SetPools(p []int) {
	client.pools = make([]int, len(p))
	copy(client.pools, p)
}

// newPeerS3Clients creates new peer clients.

## Introduction

Returns a set of temporary security credentials for applications/clients who have been authenticated through client credential grants provided by identity provider. Example providers include KeyCloak, Okta etc.

func (client *storageRESTClient) String() string {
	return client.endpoint.String()
}

// IsOnline - returns whether client failed to connect or not.
func (client *storageRESTClient) IsOnline() bool {
	return client.restClient.IsOnline() || client.IsOnlineWS()
}

// IsOnlineWS - returns whether websocket client failed to connect or not.
func (client *storageRESTClient) IsOnlineWS() bool {

  }

  @Test fun durationDefaults() {
    val client = clientTestRule.newClient()
    assertThat(client.callTimeoutMillis).isEqualTo(0)
    assertThat(client.connectTimeoutMillis).isEqualTo(10000)
    assertThat(client.readTimeoutMillis).isEqualTo(10000)
    assertThat(client.writeTimeoutMillis).isEqualTo(10000)
    assertThat(client.pingIntervalMillis).isEqualTo(0)
    assertThat(client.webSocketCloseTimeout).isEqualTo(60_000)
  }

        final FaultTolerantClient client = new FaultTolerantClient();
        final TestClient testClient = new TestClient();
        final TestListener testListener = new TestListener();
        client.setCrawlerClient(testClient);
        client.setRequestListener(testListener);
        final String url = "http://test.com/";

    client.processNextFrame() // Read server close, send client close, close connection.
    assertThat(client.closed).isFalse()
    client.listener.assertClosing(1000, "Hello!")
    client.webSocket!!.finishReader()
    client.webSocket!!.close(1000, "Hello!")
    server.processNextFrame()
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    client.listener.assertClosed(1000, "Hello!")

	states := make([]madmin.BgHealState, len(sys.peerClients))
	for idx, client := range sys.peerClients {
		client := client
		ng.Go(ctx, func() error {
			if client == nil {
				return errPeerNotReachable
			}
			st, err := client.BackgroundHealStatus(ctx)
			if err != nil {
				return err
			}
			states[idx] = st
			return nil
		}, idx, *client.host)
	}

	return states, ng.Wait()
}

import org.opensearch.threadpool.ThreadPool;
import org.opensearch.transport.client.AdminClient;
import org.opensearch.transport.client.Client;

import jakarta.annotation.PreDestroy;

/**
 * FesenClient is a client for OpenSearch.
 *
 * @author shinsuke
 *
 */
public class FesenClient implements Client {
    /**
     * HTTP address for OpenSearch.
     */

        if (client == null) {
            throw new CrawlerSystemException("CrawlerClient is null.");
        }
        clientMap.put(Pattern.compile(regex), client);
    }

    /**
     * Adds a client with a regular expression pattern at a specific position.
     * @param regex The regular expression to match URLs.
     * @param client The CrawlerClient instance.
     * @param pos The position to add the client.
     */

        url = "smb1:/home/hoge";
        client = clientFactory.getClient(url);
        assertNotNull(client);
        assertTrue(client instanceof org.codelibs.fess.crawler.client.smb1.SmbClient);

        url = "ftp:/home/hoge";
        client = clientFactory.getClient(url);
        assertNotNull(client);
        assertTrue(client instanceof FtpClient);

        url = "storage:/home/hoge";
        client = clientFactory.getClient(url);