io.milvus.client.MilvusMultiServiceClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of milvus-sdk-java Show documentation
Show all versions of milvus-sdk-java Show documentation
Java SDK for Milvus, a distributed high-performance vector database.
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 io.milvus.client;
import com.google.common.util.concurrent.ListenableFuture;
import io.milvus.connection.ClusterFactory;
import io.milvus.connection.ServerSetting;
import io.milvus.grpc.*;
import io.milvus.param.*;
import io.milvus.param.alias.*;
import io.milvus.param.bulkinsert.*;
import io.milvus.param.collection.*;
import io.milvus.param.highlevel.collection.response.ListCollectionsResponse;
import io.milvus.param.control.*;
import io.milvus.param.credential.*;
import io.milvus.param.dml.*;
import io.milvus.param.highlevel.collection.CreateSimpleCollectionParam;
import io.milvus.param.highlevel.collection.ListCollectionsParam;
import io.milvus.param.highlevel.dml.*;
import io.milvus.param.highlevel.dml.response.*;
import io.milvus.param.index.*;
import io.milvus.orm.iterator.QueryIterator;
import io.milvus.orm.iterator.SearchIterator;
import io.milvus.param.partition.*;
import io.milvus.param.resourcegroup.*;
import io.milvus.param.role.*;
import lombok.NonNull;
import org.apache.commons.collections4.CollectionUtils;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
public class MilvusMultiServiceClient implements MilvusClient {
private final ClusterFactory clusterFactory;
/**
* Sets connect param for multi milvus clusters.
* @param multiConnectParam multi server connect param
*/
public MilvusMultiServiceClient(@NonNull MultiConnectParam multiConnectParam) {
List serverSettings = multiConnectParam.getHosts().stream()
.map(host -> {
MilvusClient milvusClient = buildMilvusClient(host, multiConnectParam);
return ServerSetting.newBuilder()
.withHost(host)
.withMilvusClient(milvusClient).build();
}).collect(Collectors.toList());
boolean keepMonitor = serverSettings.size() > 1;
this.clusterFactory = ClusterFactory.newBuilder()
.withServerSetting(serverSettings)
.keepMonitor(keepMonitor)
.withQueryNodeSingleSearch(multiConnectParam.getQueryNodeSingleSearch())
.build();
}
private MilvusClient buildMilvusClient(ServerAddress host, MultiConnectParam multiConnectParam) {
long connectTimeoutMsm = multiConnectParam.getConnectTimeoutMs();
long keepAliveTimeMs = multiConnectParam.getKeepAliveTimeMs();
long keepAliveTimeoutMs = multiConnectParam.getKeepAliveTimeoutMs();
boolean keepAliveWithoutCalls = multiConnectParam.isKeepAliveWithoutCalls();
boolean secure = multiConnectParam.isSecure();
long idleTimeoutMs = multiConnectParam.getIdleTimeoutMs();
ConnectParam clusterConnectParam = ConnectParam.newBuilder()
.withHost(host.getHost())
.withPort(host.getPort())
.withConnectTimeout(connectTimeoutMsm, TimeUnit.MILLISECONDS)
.withKeepAliveTime(keepAliveTimeMs, TimeUnit.MILLISECONDS)
.withKeepAliveTimeout(keepAliveTimeoutMs, TimeUnit.MILLISECONDS)
.keepAliveWithoutCalls(keepAliveWithoutCalls)
.withSecure(secure)
.withIdleTimeout(idleTimeoutMs, TimeUnit.MILLISECONDS)
.withAuthorization(multiConnectParam.getAuthorization())
.withDatabaseName(multiConnectParam.getDatabaseName())
.build();
return new MilvusServiceClient(clusterConnectParam);
}
@Override
public MilvusClient withTimeout(long timeout, TimeUnit timeoutUnit) {
return clusterFactory.getMaster().getClient().withTimeout(timeout, timeoutUnit);
}
@Override
public MilvusClient withRetry(RetryParam retryParam) {
return clusterFactory.getMaster().getClient().withRetry(retryParam);
}
@Override
public MilvusClient withRetry(int retryTimes) {
return clusterFactory.getMaster().getClient().withRetry(retryTimes);
}
@Override
public MilvusClient withRetryInterval(long interval, TimeUnit timeUnit) {
return clusterFactory.getMaster().getClient().withRetryInterval(interval, timeUnit);
}
@Override
public void close(long maxWaitSeconds) throws InterruptedException {
this.clusterFactory.getAvailableServerSettings().parallelStream()
.forEach(serverSetting -> serverSetting.getClient().close());
this.clusterFactory.close();
}
@Override
public void setLogLevel(LogLevel level) {
this.clusterFactory.getAvailableServerSettings().parallelStream()
.forEach(serverSetting -> serverSetting.getClient().setLogLevel(level));
}
@Override
public R hasCollection(HasCollectionParam requestParam) {
return this.clusterFactory.getMaster().getClient().hasCollection(requestParam);
}
@Override
public R createDatabase(CreateDatabaseParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().createDatabase(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R dropDatabase(DropDatabaseParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().dropDatabase(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R listDatabases() {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().listDatabases())
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R alterDatabase(AlterDatabaseParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().alterDatabase(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R describeDatabase(DescribeDatabaseParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().describeDatabase(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R createCollection(CreateCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().createCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R dropCollection(DropCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().dropCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R loadCollection(LoadCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().loadCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R releaseCollection(ReleaseCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().releaseCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R renameCollection(RenameCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().renameCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R describeCollection(DescribeCollectionParam requestParam) {
return this.clusterFactory.getMaster().getClient().describeCollection(requestParam);
}
@Override
public R getCollectionStatistics(GetCollectionStatisticsParam requestParam) {
return this.clusterFactory.getMaster().getClient().getCollectionStatistics(requestParam);
}
@Override
public R showCollections(ShowCollectionsParam requestParam) {
return this.clusterFactory.getMaster().getClient().showCollections(requestParam);
}
@Override
public R alterCollection(AlterCollectionParam requestParam) {
return this.clusterFactory.getMaster().getClient().alterCollection(requestParam);
}
@Override
public R flush(FlushParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().flush(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R flushAll(boolean syncFlushAll, long syncFlushAllWaitingInterval, long syncFlushAllTimeout) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().flushAll(syncFlushAll, syncFlushAllWaitingInterval, syncFlushAllTimeout))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R createPartition(CreatePartitionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().createPartition(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R dropPartition(DropPartitionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().dropPartition(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R hasPartition(HasPartitionParam requestParam) {
return this.clusterFactory.getMaster().getClient().hasPartition(requestParam);
}
@Override
public R loadPartitions(LoadPartitionsParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().loadPartitions(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R releasePartitions(ReleasePartitionsParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().releasePartitions(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R getPartitionStatistics(GetPartitionStatisticsParam requestParam) {
return this.clusterFactory.getMaster().getClient().getPartitionStatistics(requestParam);
}
@Override
public R showPartitions(ShowPartitionsParam requestParam) {
return this.clusterFactory.getMaster().getClient().showPartitions(requestParam);
}
@Override
public R createAlias(CreateAliasParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().createAlias(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R dropAlias(DropAliasParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().dropAlias(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R alterAlias(AlterAliasParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().alterAlias(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R listAliases(ListAliasesParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().listAliases(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R createIndex(CreateIndexParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().createIndex(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R dropIndex(DropIndexParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().dropIndex(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R describeIndex(DescribeIndexParam requestParam) {
return this.clusterFactory.getMaster().getClient().describeIndex(requestParam);
}
@Override
public R getIndexState(GetIndexStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getIndexState(requestParam);
}
@Override
public R getIndexBuildProgress(GetIndexBuildProgressParam requestParam) {
return this.clusterFactory.getMaster().getClient().getIndexBuildProgress(requestParam);
}
@Override
public R alterIndex(AlterIndexParam requestParam) {
return this.clusterFactory.getMaster().getClient().alterIndex(requestParam);
}
@Override
public R insert(InsertParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().insert(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public ListenableFuture> insertAsync(InsertParam requestParam) {
List>> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().insertAsync(requestParam))
.collect(Collectors.toList());
return response.get(0);
}
@Override
public R upsert(UpsertParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().upsert(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public ListenableFuture> upsertAsync(UpsertParam requestParam) {
List>> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().upsertAsync(requestParam))
.collect(Collectors.toList());
return response.get(0);
}
@Override
public R delete(DeleteParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().delete(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
// @Override
// public R bulkload(@NonNull BulkloadParam requestParam) {
// List> response = this.clusterFactory.getAvailableServerSettings().stream()
// .map(serverSetting -> serverSetting.getClient().bulkload(requestParam))
// .collect(Collectors.toList());
// return handleResponse(response);
// }
//
// @Override
// public R getBulkloadState(GetBulkloadStateParam requestParam) {
// return this.clusterFactory.getMaster().getClient().getBulkloadState(requestParam);
// }
//
// @Override
// public R listBulkloadTasks(@NonNull ListBulkloadTasksParam requestParam) {
// return this.clusterFactory.getMaster().getClient().listBulkloadTasks(requestParam);
// }
@Override
public R search(SearchParam requestParam) {
return this.clusterFactory.getMaster().getClient().search(requestParam);
}
@Override
public ListenableFuture> searchAsync(SearchParam requestParam) {
return this.clusterFactory.getMaster().getClient().searchAsync(requestParam);
}
@Override
public R hybridSearch(HybridSearchParam requestParam) {
return this.clusterFactory.getMaster().getClient().hybridSearch(requestParam);
}
@Override
public ListenableFuture> hybridSearchAsync(HybridSearchParam requestParam) {
return this.clusterFactory.getMaster().getClient().hybridSearchAsync(requestParam);
}
@Override
public R query(QueryParam requestParam) {
return this.clusterFactory.getMaster().getClient().query(requestParam);
}
@Override
public ListenableFuture> queryAsync(QueryParam requestParam) {
return this.clusterFactory.getMaster().getClient().queryAsync(requestParam);
}
@Override
public R getMetrics(GetMetricsParam requestParam) {
return this.clusterFactory.getMaster().getClient().getMetrics(requestParam);
}
@Override
public R getFlushState(GetFlushStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getFlushState(requestParam);
}
@Override
public R getFlushAllState(GetFlushAllStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getFlushAllState(requestParam);
}
@Override
public R getPersistentSegmentInfo(GetPersistentSegmentInfoParam requestParam) {
return this.clusterFactory.getMaster().getClient().getPersistentSegmentInfo(requestParam);
}
@Override
public R getQuerySegmentInfo(GetQuerySegmentInfoParam requestParam) {
return this.clusterFactory.getMaster().getClient().getQuerySegmentInfo(requestParam);
}
@Override
public R getReplicas(GetReplicasParam requestParam) {
return this.clusterFactory.getMaster().getClient().getReplicas(requestParam);
}
@Override
public R loadBalance(LoadBalanceParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().loadBalance(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R getCompactionState(GetCompactionStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getCompactionState(requestParam);
}
@Override
public R manualCompact(ManualCompactParam requestParam) {
return null;
}
@Override
public R getCompactionStateWithPlans(GetCompactionPlansParam requestParam) {
return this.clusterFactory.getMaster().getClient().getCompactionStateWithPlans(requestParam);
}
@Override
public R createCredential(CreateCredentialParam requestParam) {
return this.clusterFactory.getMaster().getClient().createCredential(requestParam);
}
@Override
public R updateCredential(UpdateCredentialParam requestParam) {
return this.clusterFactory.getMaster().getClient().updateCredential(requestParam);
}
@Override
public R deleteCredential(DeleteCredentialParam requestParam) {
return this.clusterFactory.getMaster().getClient().deleteCredential(requestParam);
}
@Override
public R listCredUsers(ListCredUsersParam requestParam) {
return this.clusterFactory.getMaster().getClient().listCredUsers(requestParam);
}
@Override
public R createRole(CreateRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().createRole(requestParam);
}
@Override
public R dropRole(DropRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().dropRole(requestParam);
}
@Override
public R addUserToRole(AddUserToRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().addUserToRole(requestParam);
}
@Override
public R removeUserFromRole(RemoveUserFromRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().removeUserFromRole(requestParam);
}
@Override
public R selectRole(SelectRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().selectRole(requestParam);
}
@Override
public R selectUser(SelectUserParam requestParam) {
return this.clusterFactory.getMaster().getClient().selectUser(requestParam);
}
@Override
public R grantRolePrivilege(GrantRolePrivilegeParam requestParam) {
return this.clusterFactory.getMaster().getClient().grantRolePrivilege(requestParam);
}
@Override
public R revokeRolePrivilege(RevokeRolePrivilegeParam requestParam) {
return this.clusterFactory.getMaster().getClient().revokeRolePrivilege(requestParam);
}
@Override
public R selectGrantForRole(SelectGrantForRoleParam requestParam) {
return this.clusterFactory.getMaster().getClient().selectGrantForRole(requestParam);
}
@Override
public R selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam requestParam) {
return this.clusterFactory.getMaster().getClient().selectGrantForRoleAndObject(requestParam);
}
@Override
public R bulkInsert(BulkInsertParam requestParam) {
return this.clusterFactory.getMaster().getClient().bulkInsert(requestParam);
}
@Override
public R getBulkInsertState(GetBulkInsertStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getBulkInsertState(requestParam);
}
@Override
public R listBulkInsertTasks(ListBulkInsertTasksParam requestParam) {
return this.clusterFactory.getMaster().getClient().listBulkInsertTasks(requestParam);
}
public R checkHealth(){
return this.clusterFactory.getMaster().getClient().checkHealth();
}
public R getVersion() {
return this.clusterFactory.getMaster().getClient().getVersion();
}
@Override
public R getLoadingProgress(GetLoadingProgressParam requestParam) {
return this.clusterFactory.getMaster().getClient().getLoadingProgress(requestParam);
}
@Override
public R getLoadState(GetLoadStateParam requestParam) {
return this.clusterFactory.getMaster().getClient().getLoadState(requestParam);
}
@Override
public R createResourceGroup(CreateResourceGroupParam requestParam) {
return this.clusterFactory.getMaster().getClient().createResourceGroup(requestParam);
}
@Override
public R updateResourceGroups(UpdateResourceGroupsParam requestParam) {
return this.clusterFactory.getMaster().getClient().updateResourceGroups(requestParam);
}
@Override
public R dropResourceGroup(DropResourceGroupParam requestParam) {
return this.clusterFactory.getMaster().getClient().dropResourceGroup(requestParam);
}
@Override
public R listResourceGroups(ListResourceGroupsParam requestParam) {
return this.clusterFactory.getMaster().getClient().listResourceGroups(requestParam);
}
@Override
public R describeResourceGroup(DescribeResourceGroupParam requestParam) {
return this.clusterFactory.getMaster().getClient().describeResourceGroup(requestParam);
}
@Override
public R transferNode(TransferNodeParam requestParam) {
return this.clusterFactory.getMaster().getClient().transferNode(requestParam);
}
@Override
public R transferReplica(TransferReplicaParam requestParam) {
return this.clusterFactory.getMaster().getClient().transferReplica(requestParam);
}
///////////////////// High Level API//////////////////////
@Override
public R createCollection(CreateSimpleCollectionParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().createCollection(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R listCollections(ListCollectionsParam requestParam) {
return this.clusterFactory.getMaster().getClient().listCollections(requestParam);
}
@Override
public R insert(InsertRowsParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().parallelStream()
.map(serverSetting -> serverSetting.getClient().insert(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R delete(DeleteIdsParam requestParam) {
List> response = this.clusterFactory.getAvailableServerSettings().stream()
.map(serverSetting -> serverSetting.getClient().delete(requestParam))
.collect(Collectors.toList());
return handleResponse(response);
}
@Override
public R get(GetIdsParam requestParam) {
return this.clusterFactory.getMaster().getClient().get(requestParam);
}
@Override
public R query(QuerySimpleParam requestParam) {
return this.clusterFactory.getMaster().getClient().query(requestParam);
}
@Override
public R search(SearchSimpleParam requestParam) {
return this.clusterFactory.getMaster().getClient().search(requestParam);
}
@Override
public R queryIterator(QueryIteratorParam requestParam) {
return this.clusterFactory.getMaster().getClient().queryIterator(requestParam);
}
@Override
public R searchIterator(SearchIteratorParam requestParam) {
return this.clusterFactory.getMaster().getClient().searchIterator(requestParam);
}
private R handleResponse(List> response) {
if (CollectionUtils.isNotEmpty(response)) {
R rSuccess = null;
for (R singleRes : response) {
if (R.Status.Success.getCode() == singleRes.getStatus()) {
rSuccess = singleRes;
} else {
return singleRes;
}
}
if (null != rSuccess) {
return rSuccess;
}
}
return R.failed(R.Status.Unknown, "Response is empty.");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy