frostfs-sdk-java/client/src/main/java/info/FrostFS/sdk/services/FrostFSClient.java

package info.FrostFS.sdk.services;

import frostFS.session.Types;
import info.FrostFS.sdk.tools.ClientSettings;
import info.FrostFS.sdk.tools.PutObjectParameters;
import info.FrostFS.sdk.dto.container.Container;
import info.FrostFS.sdk.dto.container.ContainerId;
import info.FrostFS.sdk.dto.SessionToken;
import info.FrostFS.sdk.dto.Version;
import info.FrostFS.sdk.dto.netmap.NetmapSnapshot;
import info.FrostFS.sdk.dto.netmap.NodeInfo;
import info.FrostFS.sdk.dto.object.ObjectFilter;
import info.FrostFS.sdk.dto.object.ObjectFrostFS;
import info.FrostFS.sdk.dto.object.ObjectHeader;
import info.FrostFS.sdk.dto.object.ObjectId;
import info.FrostFS.sdk.services.impl.*;
import info.FrostFS.sdk.tools.ClientEnvironment;
import info.FrostFS.sdk.tools.NetworkSettings;
import io.grpc.Channel;

import java.util.List;

import static info.FrostFS.sdk.GrpcClient.initGrpcChannel;
import static java.util.Objects.isNull;

public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClient, SessionClient, ToolsClient {
    private final ContainerService containerService;
    private final NetmapService netmapService;
    private final ObjectService objectService;
    private final SessionService sessionService;
    private final ObjectTools objectTools;

    public FrostFSClient(ClientSettings clientSettings) {
        if (isNull(clientSettings)) {
            throw new IllegalArgumentException("Options must be initialized");
        }

        clientSettings.validate();

        Channel channel = initGrpcChannel(clientSettings.getHost(), clientSettings.getCreds());

        ClientEnvironment clientEnvironment =
                new ClientEnvironment(clientSettings.getKey(), channel, new Version(2, 13), this);

        this.containerService = new ContainerService(clientEnvironment);
        this.netmapService = new NetmapService(clientEnvironment);
        this.sessionService = new SessionService(clientEnvironment);
        this.objectService = new ObjectService(clientEnvironment);
        this.objectTools = new ObjectTools(clientEnvironment);
        checkFrostFsVersionSupport(clientEnvironment.getVersion());
    }

    private void checkFrostFsVersionSupport(Version version) {
        var localNodeInfo = netmapService.getLocalNodeInfo();
        if (!localNodeInfo.getVersion().isSupported(version)) {
            var msg = String.format("FrostFS %s is not supported.", localNodeInfo.getVersion());
            System.out.println(msg);
            throw new IllegalArgumentException(msg);
        }
    }

    @Override
    public Container getContainer(ContainerId cid) {
        return containerService.getContainer(cid);
    }

    @Override
    public List<ContainerId> listContainers() {
        return containerService.listContainers();
    }

    @Override
    public ContainerId createContainer(Container container) {
        return containerService.createContainer(container);
    }

    @Override
    public void deleteContainer(ContainerId cid) {
        containerService.deleteContainer(cid);
    }

    @Override
    public ObjectHeader getObjectHead(ContainerId containerId, ObjectId objectId) {
        return objectService.getObjectHead(containerId, objectId);
    }

    @Override
    public ObjectFrostFS getObject(ContainerId containerId, ObjectId objectId) {
        return objectService.getObject(containerId, objectId);
    }

    @Override
    public ObjectId putObject(PutObjectParameters parameters) {
        return objectService.putObject(parameters);
    }

    @Override
    public void deleteObject(ContainerId containerId, ObjectId objectId) {
        objectService.deleteObject(containerId, objectId);
    }

    @Override
    public Iterable<ObjectId> searchObjects(ContainerId cid, ObjectFilter... filters) {
        return objectService.searchObjects(cid, filters);
    }

    @Override
    public NetmapSnapshot getNetmapSnapshot() {
        return netmapService.getNetmapSnapshot();
    }

    @Override
    public NodeInfo getLocalNodeInfo() {
        return netmapService.getLocalNodeInfo();
    }

    @Override
    public NetworkSettings getNetworkSettings() {
        return netmapService.getNetworkSettings();
    }

    @Override
    public SessionToken createSession(long expiration) {
        return sessionService.createSession(expiration);
    }

    public Types.SessionToken createSessionInternal(long expiration) {
        return sessionService.createSessionInternal(expiration);
    }

    @Override
    public ObjectId calculateObjectId(ObjectHeader header) {
        return objectTools.calculateObjectId(header);
    }
}