potyarkin/frostfs-sdk-java
1
0
Fork 0
forked from TrueCloudLab/frostfs-sdk-java
Code Pull requests Activity

[#1] add client environment

Browse source 
add client cut
code cleanup
Signed-off-by: Ori Bruk <o.bruk@yadro.com>
This commit is contained in:
Ori Bruk 2024-07-22 19:13:52 +03:00
parent dc0eef770c
commit b0db7df192
95 changed files with 1202 additions and 560 deletions
Download patch file Download diff file Expand all files Collapse all files

12
client/pom.xml
View file

@ -25,9 +25,19 @@
</dependency>
<dependency>
<groupId>info.FrostFS.sdk</groupId>
<artifactId>modelsV2</artifactId>
<artifactId>models</artifactId>
<version>0.1.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.4</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.17.0</version>
</dependency>
</dependencies>
</project>

51
client/src/main/java/info/FrostFS/sdk/Main.java
View file

@ -1,14 +1,22 @@
package info.FrostFS.sdk;
import info.FrostFS.sdk.dto.container.Container;
import info.FrostFS.sdk.dto.container.ContainerId;
import info.FrostFS.sdk.enums.BasicAcl;
import info.FrostFS.sdk.enums.ObjectType;
import info.FrostFS.sdk.jdo.*;
import info.FrostFS.sdk.jdo.netmap.PlacementPolicy;
import info.FrostFS.sdk.jdo.netmap.Replica;
import info.FrostFS.sdk.dto.netmap.PlacementPolicy;
import info.FrostFS.sdk.dto.netmap.Replica;
import info.FrostFS.sdk.dto.object.ObjectAttribute;
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.FrostFSClient;
import info.FrostFS.sdk.tools.ClientSettings;
import info.FrostFS.sdk.tools.PutObjectParameters;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.List;
public class Main {
@ -18,37 +26,42 @@ public class Main {
/*
var res2 = frostFSClient.searchObjectsAsync(new ContainerId("EQGx2QeYHJb53uRwYGzcQaW191sZpdNrjutk6veUSV2R"));
*/
ObjectFrostFs res3 = frostFSClient
.getObjectAsync(new ContainerId("EQGx2QeYHJb53uRwYGzcQaW191sZpdNrjutk6veUSV2R"), new ObjectId("85orCLKSu3X1jGiTFmwmTUsBU88RBARNwuRwrEy5pyww"));
var ttttt = frostFSClient.getNetworkSettingsAsync();
Container container2 = frostFSClient.getContainerAsync(new ContainerId("EQGx2QeYHJb53uRwYGzcQaW191sZpdNrjutk6veUSV2R"));
var placementPolicy = new PlacementPolicy(true, new Replica[]{new Replica(1)});
var containerId = frostFSClient.createContainerAsync(new Container(BasicAcl.PUBLIC_RW, placementPolicy));
var containerId = frostFSClient.createContainer(new Container(BasicAcl.PUBLIC_RW, placementPolicy));
Thread.sleep(1000);
FileInputStream file = null;
try {
file = new FileInputStream("/home/ori/Desktop/cat.jpg");
var cat = new ObjectHeader(containerId, ObjectType.REGULAR, new ObjectAttribute[]{new ObjectAttribute("Filename", "cat.jpg")});
frostFSClient.putObjectAsync(cat, file);
var cat = new ObjectHeader(containerId, ObjectType.REGULAR, Collections.singletonList(new ObjectAttribute("Filename", "cat3.jpg")));
var params = new PutObjectParameters(cat, file, false, 1024);
var tty = frostFSClient.putObject(params);
System.out.println(1);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
var res = frostFSClient.searchObjectsAsync(containerId);
var res = frostFSClient.searchObjects(containerId);
ObjectFrostFS res3 = frostFSClient
.getObject(new ContainerId("EQGx2QeYHJb53uRwYGzcQaW191sZpdNrjutk6veUSV2R"), new ObjectId("85orCLKSu3X1jGiTFmwmTUsBU88RBARNwuRwrEy5pyww"));
Container container = frostFSClient.getContainerAsync(containerId);
List<ContainerId> containerIds = frostFSClient.listContainersAsync();
var ttttt = frostFSClient.getNetworkSettings();
Container container2 = frostFSClient.getContainer(new ContainerId("EQGx2QeYHJb53uRwYGzcQaW191sZpdNrjutk6veUSV2R"));
Container container = frostFSClient.getContainer(containerId);
List<ContainerId> containerIds = frostFSClient.listContainers();
/*
frostFSClient.deleteContainerAsync(containerId);
*/
containerIds = frostFSClient.listContainersAsync();
containerIds = frostFSClient.listContainers();
System.out.println();
}
}

7
client/src/main/java/info/FrostFS/sdk/RequestConstructor.java
View file

@ -2,8 +2,9 @@ package info.FrostFS.sdk;
import com.google.protobuf.AbstractMessage;
import frostFS.session.Types;
import info.FrostFS.sdk.jdo.MetaHeader;
import info.FrostFS.sdk.dto.MetaHeader;
import info.FrostFS.sdk.mappers.MetaHeaderMapper;
import info.FrostFS.sdk.tools.ECDsa;
import static info.FrostFS.sdk.RequestSigner.signMessagePart;
import static java.util.Objects.isNull;
@ -27,7 +28,7 @@ public class RequestConstructor {
frostFS.refs.Types.ContainerID cid,
frostFS.refs.Types.ObjectID oid,
Types.ObjectSessionContext.Verb verb,
byte[] publicKey, byte[] privateKey) {
ECDsa key) {
var headerField = request.getDescriptorForType().findFieldByName("meta_header");
var header = (Types.RequestMetaHeader) request.getField(headerField);
if (header.getSessionToken().getSerializedSize() > 0) {
@ -41,7 +42,7 @@ public class RequestConstructor {
var body = sessionToken.getBody().toBuilder().setObject(ctx).build();
sessionToken = sessionToken.toBuilder()
.setSignature(signMessagePart(publicKey, privateKey, body))
.setSignature(signMessagePart(key, body))
.setBody(body)
.build();

43
client/src/main/java/info/FrostFS/sdk/RequestSigner.java
View file

@ -3,6 +3,7 @@ package info.FrostFS.sdk;
import com.google.protobuf.AbstractMessage;
import com.google.protobuf.ByteString;
import frostFS.session.Types;
import info.FrostFS.sdk.tools.ECDsa;
import org.apache.commons.codec.digest.DigestUtils;
import org.bouncycastle.asn1.sec.SECNamedCurves;
import org.bouncycastle.asn1.sec.SECObjectIdentifiers;
@ -14,19 +15,18 @@ import org.bouncycastle.crypto.signers.HMacDSAKCalculator;
import java.math.BigInteger;
import java.security.Signature;
import static info.FrostFS.sdk.KeyExtension.loadPrivateKey;
import static org.bouncycastle.crypto.util.DigestFactory.createSHA256;
import static org.bouncycastle.util.BigIntegers.asUnsignedByteArray;
public class RequestSigner {
public static final int RFC6979_SIGNATURE_SIZE = 64;
public static byte[] signData(byte[] privateKey, byte[] data) {
public static byte[] signData(ECDsa key, byte[] data) {
var hash = new byte[65];
hash[0] = 0x04;
try {
Signature signature = Signature.getInstance("NONEwithECDSAinP1363Format");
signature.initSign(loadPrivateKey(privateKey));
signature.initSign(key.getPrivateKey());
signature.update(DigestUtils.sha512(data));
byte[] sig = signature.sign();
System.arraycopy(sig, 0, hash, 1, sig.length);
@ -37,12 +37,12 @@ public class RequestSigner {
return hash;
}
public static byte[] signRFC6979(byte[] privateKey, byte[] data) {
public static byte[] signRFC6979(ECDsa key, byte[] data) {
var digest = createSHA256();
var secp256R1 = SECNamedCurves.getByOID(SECObjectIdentifiers.secp256r1);
var ecParameters = new ECDomainParameters(secp256R1.getCurve(), secp256R1.getG(), secp256R1.getN());
var ecPrivateKey = new ECPrivateKeyParameters(new BigInteger(1, privateKey), ecParameters);
var ecPrivateKey = new ECPrivateKeyParameters(new BigInteger(1, key.getPrivateKeyByte()), ecParameters);
var signer = new ECDSASigner(new HMacDSAKCalculator(digest));
var hash = new byte[digest.getDigestSize()];
@ -62,36 +62,29 @@ public class RequestSigner {
return signature;
}
public static frostFS.refs.Types.SignatureRFC6979 signRFC6979(byte[] publicKey,
byte[] privateKey,
AbstractMessage message) {
public static frostFS.refs.Types.SignatureRFC6979 signRFC6979(ECDsa key, AbstractMessage message) {
return frostFS.refs.Types.SignatureRFC6979.newBuilder()
.setKey(ByteString.copyFrom(publicKey))
.setSign(ByteString.copyFrom(signRFC6979(privateKey, message.toByteArray())))
.setKey(ByteString.copyFrom(key.getPublicKeyByte()))
.setSign(ByteString.copyFrom(signRFC6979(key, message.toByteArray())))
.build();
}
public static frostFS.refs.Types.SignatureRFC6979 signRFC6979(byte[] publicKey,
byte[] privateKey,
ByteString data) {
public static frostFS.refs.Types.SignatureRFC6979 signRFC6979(ECDsa key, ByteString data) {
return frostFS.refs.Types.SignatureRFC6979.newBuilder()
.setKey(ByteString.copyFrom(publicKey))
.setSign(ByteString.copyFrom(signRFC6979(privateKey, data.toByteArray())))
.setKey(ByteString.copyFrom(key.getPublicKeyByte()))
.setSign(ByteString.copyFrom(signRFC6979(key, data.toByteArray())))
.build();
}
public static frostFS.refs.Types.Signature signMessagePart(byte[] publicKey,
byte[] privateKey,
AbstractMessage data) {
public static frostFS.refs.Types.Signature signMessagePart(ECDsa key, AbstractMessage data) {
var data2Sign = data.getSerializedSize() == 0 ? new byte[]{} : data.toByteArray();
return frostFS.refs.Types.Signature.newBuilder()
.setKey(ByteString.copyFrom(publicKey))
.setSign(ByteString.copyFrom(signData(privateKey, data2Sign)))
.setKey(ByteString.copyFrom(key.getPublicKeyByte()))
.setSign(ByteString.copyFrom(signData(key, data2Sign)))
.build();
}
public static void sign(AbstractMessage.Builder request, byte[] publicKey, byte[] privateKey) {
public static void sign(AbstractMessage.Builder request, ECDsa key) {
var meta = (AbstractMessage) request.getField(request.getDescriptorForType().findFieldByName("meta_header"));
var body = (AbstractMessage) request.getField(request.getDescriptorForType().findFieldByName("body"));
var verify = (AbstractMessage) request.getField(request.getDescriptorForType().findFieldByName("verify_header"));
@ -109,7 +102,7 @@ public class RequestSigner {
if (verifyOrigin.getSerializedSize() == 0) {
verifyBuilder.setField(
verifyBuilder.getDescriptorForType().findFieldByName("body_signature"),
signMessagePart(publicKey, privateKey, body)
signMessagePart(key, body)
);
} else {
verifyBuilder.setField(verifyBuilder.getDescriptorForType().findFieldByName("origin"), verifyOrigin);
@ -117,11 +110,11 @@ public class RequestSigner {
verifyBuilder.setField(
verifyBuilder.getDescriptorForType().findFieldByName("meta_signature"),
signMessagePart(publicKey, privateKey, meta)
signMessagePart(key, meta)
);
verifyBuilder.setField(
verifyBuilder.getDescriptorForType().findFieldByName("origin_signature"),
signMessagePart(publicKey, privateKey, verifyOrigin)
signMessagePart(key, verifyOrigin)
);
request.setField(request.getDescriptorForType().findFieldByName("verify_header"), verifyBuilder.build());

4
client/src/main/java/info/FrostFS/sdk/Verifier.java
View file

@ -16,7 +16,7 @@ import java.security.PublicKey;
import java.security.Signature;
import java.util.Arrays;
import static info.FrostFS.sdk.KeyExtension.getPublicKeyByPublic;
import static info.FrostFS.sdk.KeyExtension.getPublicKeyFromBytes;
import static java.util.Objects.isNull;
import static org.bouncycastle.crypto.util.DigestFactory.createSHA256;
import static org.bouncycastle.util.BigIntegers.fromUnsignedByteArray;
@ -99,7 +99,7 @@ public class Verifier {
public static boolean verifyMessagePart(Types.Signature sig, AbstractMessage data) {
if (sig.getSerializedSize() == 0 || sig.getKey().isEmpty() || sig.getSign().isEmpty()) return false;
var publicKey = getPublicKeyByPublic(sig.getKey().toByteArray());
var publicKey = getPublicKeyFromBytes(sig.getKey().toByteArray());
var data2Verify = data.getSerializedSize() == 0 ? new byte[]{} : data.toByteArray();
return verifyData(publicKey, data2Verify, sig.getSign().toByteArray());

12
client/src/main/java/info/FrostFS/sdk/services/ContainerClient.java
View file

@ -1,16 +1,16 @@
package info.FrostFS.sdk.services;
import info.FrostFS.sdk.jdo.Container;
import info.FrostFS.sdk.jdo.ContainerId;
import info.FrostFS.sdk.dto.container.Container;
import info.FrostFS.sdk.dto.container.ContainerId;
import java.util.List;
public interface ContainerClient {
Container getContainerAsync(ContainerId cid);
Container getContainer(ContainerId cid);
List<ContainerId> listContainersAsync();
List<ContainerId> listContainers();
ContainerId createContainerAsync(Container container);
ContainerId createContainer(Container container);
void deleteContainerAsync(ContainerId cid);
void deleteContainer(ContainerId cid);
}

6
client/src/main/java/info/FrostFS/sdk/services/ContextAccessor.java
View file

@ -3,7 +3,7 @@ package info.FrostFS.sdk.services;
import info.FrostFS.sdk.tools.ClientEnvironment;
public class ContextAccessor {
protected ClientEnvironment context;
private final ClientEnvironment context;
public ContextAccessor(ClientEnvironment context) {
this.context = context;
@ -12,8 +12,4 @@ public class ContextAccessor {
public ClientEnvironment getContext() {
return context;
}
public void setContext(ClientEnvironment context) {
this.context = context;
}
}

99
client/src/main/java/info/FrostFS/sdk/services/FrostFSClient.java
View file

@ -1,19 +1,23 @@
package info.FrostFS.sdk.services;
import frostFS.session.Types;
import info.FrostFS.sdk.ClientSettings;
import info.FrostFS.sdk.jdo.*;
import info.FrostFS.sdk.jdo.netmap.NetmapSnapshot;
import info.FrostFS.sdk.jdo.netmap.NodeInfo;
import info.FrostFS.sdk.services.impl.ContainerService;
import info.FrostFS.sdk.services.impl.NetmapService;
import info.FrostFS.sdk.services.impl.ObjectService;
import info.FrostFS.sdk.services.impl.SessionService;
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.io.FileInputStream;
import java.util.List;
import static info.FrostFS.sdk.GrpcClient.initGrpcChannel;
@ -24,7 +28,7 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
private final NetmapService netmapService;
private final ObjectService objectService;
private final SessionService sessionService;
private final ClientEnvironment clientEnvironment;
private final ObjectTools objectTools;
public FrostFSClient(ClientSettings clientSettings) {
if (isNull(clientSettings)) {
@ -32,20 +36,22 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
}
clientSettings.validate();
Channel channel = initGrpcChannel(clientSettings.getHost(), clientSettings.getCreds());
this.clientEnvironment =
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.getLocalNodeInfoAsync();
var localNodeInfo = netmapService.getLocalNodeInfo();
if (!localNodeInfo.getVersion().isSupported(version)) {
var msg = String.format("FrostFS %s is not supported.", localNodeInfo.getVersion());
System.out.println(msg);
@ -54,81 +60,76 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
}
@Override
public Container getContainerAsync(ContainerId cid) {
return containerService.getContainerAsync(cid);
public Container getContainer(ContainerId cid) {
return containerService.getContainer(cid);
}
@Override
public List<ContainerId> listContainersAsync() {
return containerService.listContainersAsync();
public List<ContainerId> listContainers() {
return containerService.listContainers();
}
@Override
public ContainerId createContainerAsync(Container container) {
return containerService.createContainerAsync(container);
public ContainerId createContainer(Container container) {
return containerService.createContainer(container);
}
@Override
public void deleteContainerAsync(ContainerId cid) {
containerService.deleteContainerAsync(cid);
public void deleteContainer(ContainerId cid) {
containerService.deleteContainer(cid);
}
@Override
public ObjectHeader getObjectHeadAsync(ContainerId containerId, ObjectId objectId) {
return objectService.getObjectHeadAsync(containerId, objectId);
public ObjectHeader getObjectHead(ContainerId containerId, ObjectId objectId) {
return objectService.getObjectHead(containerId, objectId);
}
@Override
public ObjectFrostFs getObjectAsync(ContainerId containerId, ObjectId objectId) {
return objectService.getObjectAsync(containerId, objectId);
public ObjectFrostFS getObject(ContainerId containerId, ObjectId objectId) {
return objectService.getObject(containerId, objectId);
}
@Override
public ObjectId putObjectAsync(ObjectHeader header, FileInputStream payload) {
return objectService.putObjectAsync(header, payload);
public ObjectId putObject(PutObjectParameters parameters) {
return objectService.putObject(parameters);
}
@Override
public ObjectId putObjectAsync(ObjectHeader header, byte[] payload) {
return objectService.putObjectAsync(header, payload);
public void deleteObject(ContainerId containerId, ObjectId objectId) {
objectService.deleteObject(containerId, objectId);
}
@Override
public void deleteObjectAsync(ContainerId containerId, ObjectId objectId) {
objectService.deleteObjectAsync(containerId, objectId);
public Iterable<ObjectId> searchObjects(ContainerId cid, ObjectFilter... filters) {
return objectService.searchObjects(cid, filters);
}
@Override
public Iterable<ObjectId> searchObjectsAsync(ContainerId cid, ObjectFilter... filters) {
return objectService.searchObjectsAsync(cid, filters);
public NetmapSnapshot getNetmapSnapshot() {
return netmapService.getNetmapSnapshot();
}
@Override
public NetmapSnapshot getNetmapSnapshotAsync() {
return netmapService.getNetmapSnapshotAsync();
public NodeInfo getLocalNodeInfo() {
return netmapService.getLocalNodeInfo();
}
@Override
public NodeInfo getLocalNodeInfoAsync() {
return netmapService.getLocalNodeInfoAsync();
public NetworkSettings getNetworkSettings() {
return netmapService.getNetworkSettings();
}
@Override
public NetworkSettings getNetworkSettingsAsync() {
return netmapService.getNetworkSettingsAsync();
public SessionToken createSession(long expiration) {
return sessionService.createSession(expiration);
}
public Types.SessionToken createSessionInternal(long expiration) {
return sessionService.createSessionInternal(expiration);
}
@Override
public SessionToken createSessionAsync(long expiration) {
return sessionService.createSessionAsync(expiration);
}
public Types.SessionToken createSessionInternalAsync(long expiration) {
return sessionService.createSessionInternalAsync(expiration);
}
@Override
public ObjectId CalculateObjectId(ObjectHeader header) {
return null;
public ObjectId calculateObjectId(ObjectHeader header) {
return objectTools.calculateObjectId(header);
}
}

11
client/src/main/java/info/FrostFS/sdk/services/NetmapClient.java
View file

@ -1,14 +1,13 @@
package info.FrostFS.sdk.services;
import info.FrostFS.sdk.jdo.netmap.NetmapSnapshot;
import info.FrostFS.sdk.jdo.netmap.NodeInfo;
import info.FrostFS.sdk.dto.netmap.NetmapSnapshot;
import info.FrostFS.sdk.dto.netmap.NodeInfo;
import info.FrostFS.sdk.tools.NetworkSettings;
public interface NetmapClient {
NetmapSnapshot getNetmapSnapshot();
NetmapSnapshot getNetmapSnapshotAsync();
NodeInfo getLocalNodeInfo();
NodeInfo getLocalNodeInfoAsync();
NetworkSettings getNetworkSettingsAsync();
NetworkSettings getNetworkSettings();
}

21
client/src/main/java/info/FrostFS/sdk/services/ObjectClient.java
View file

@ -1,19 +1,20 @@
package info.FrostFS.sdk.services;
import info.FrostFS.sdk.jdo.*;
import java.io.FileInputStream;
import info.FrostFS.sdk.dto.container.ContainerId;
import info.FrostFS.sdk.tools.PutObjectParameters;
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;
public interface ObjectClient {
ObjectHeader getObjectHeadAsync(ContainerId containerId, ObjectId objectId);
ObjectHeader getObjectHead(ContainerId containerId, ObjectId objectId);
ObjectFrostFs getObjectAsync(ContainerId containerId, ObjectId objectId);
ObjectFrostFS getObject(ContainerId containerId, ObjectId objectId);
ObjectId putObjectAsync(ObjectHeader header, FileInputStream payload);
ObjectId putObject(PutObjectParameters parameters);
ObjectId putObjectAsync(ObjectHeader header, byte[] payload);
void deleteObject(ContainerId containerId, ObjectId objectId);
void deleteObjectAsync(ContainerId containerId, ObjectId objectId);
Iterable<ObjectId> searchObjectsAsync(ContainerId cid, ObjectFilter... filters);
Iterable<ObjectId> searchObjects(ContainerId cid, ObjectFilter... filters);
}

5
client/src/main/java/info/FrostFS/sdk/services/SessionClient.java
View file

@ -1,8 +1,7 @@
package info.FrostFS.sdk.services;
import info.FrostFS.sdk.jdo.SessionToken;
import info.FrostFS.sdk.dto.SessionToken;
public interface SessionClient {
SessionToken createSessionAsync(long expiration);
SessionToken createSession(long expiration);
}

6
client/src/main/java/info/FrostFS/sdk/services/ToolsClient.java
View file

@ -1,8 +1,8 @@
package info.FrostFS.sdk.services;
import info.FrostFS.sdk.jdo.ObjectHeader;
import info.FrostFS.sdk.jdo.ObjectId;
import info.FrostFS.sdk.dto.object.ObjectHeader;
import info.FrostFS.sdk.dto.object.ObjectId;
public interface ToolsClient {
ObjectId CalculateObjectId(ObjectHeader header);
ObjectId calculateObjectId(ObjectHeader header);
}

46
client/src/main/java/info/FrostFS/sdk/services/impl/ContainerService.java
View file

@ -3,10 +3,10 @@ package info.FrostFS.sdk.services.impl;
import frostFS.container.ContainerServiceGrpc;
import frostFS.container.Service;
import info.FrostFS.sdk.Verifier;
import info.FrostFS.sdk.jdo.Container;
import info.FrostFS.sdk.jdo.ContainerId;
import info.FrostFS.sdk.mappers.ContainerIdMapper;
import info.FrostFS.sdk.mappers.ContainerMapper;
import info.FrostFS.sdk.dto.container.Container;
import info.FrostFS.sdk.dto.container.ContainerId;
import info.FrostFS.sdk.mappers.container.ContainerIdMapper;
import info.FrostFS.sdk.mappers.container.ContainerMapper;
import info.FrostFS.sdk.mappers.OwnerIdMapper;
import info.FrostFS.sdk.mappers.VersionMapper;
import info.FrostFS.sdk.services.ContainerClient;
@ -21,14 +21,14 @@ import static info.FrostFS.sdk.RequestSigner.sign;
import static info.FrostFS.sdk.RequestSigner.signRFC6979;
public class ContainerService extends ContextAccessor implements ContainerClient {
private final ContainerServiceGrpc.ContainerServiceBlockingStub containerServiceAsyncClient;
private final ContainerServiceGrpc.ContainerServiceBlockingStub serviceBlockingStub;
public ContainerService(ClientEnvironment clientEnvironment) {
super(clientEnvironment);
this.containerServiceAsyncClient = ContainerServiceGrpc.newBlockingStub(clientEnvironment.getChannel());
this.serviceBlockingStub = ContainerServiceGrpc.newBlockingStub(clientEnvironment.getChannel());
}
public Container getContainerAsync(ContainerId cid) {
public Container getContainer(ContainerId cid) {
var request = Service.GetRequest.newBuilder()
.setBody(
Service.GetRequest.Body.newBuilder()
@ -37,26 +37,26 @@ public class ContainerService extends ContextAccessor implements ContainerClient
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = containerServiceAsyncClient.get(request.build());
var response = serviceBlockingStub.get(request.build());
Verifier.checkResponse(response);
return ContainerMapper.toModel(response.getBody().getContainer());
}
public List<ContainerId> listContainersAsync() {
public List<ContainerId> listContainers() {
var request = Service.ListRequest.newBuilder()
.setBody(
Service.ListRequest.Body.newBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(context.getOwnerId()))
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.build()
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = containerServiceAsyncClient.list(request.build());
var response = serviceBlockingStub.list(request.build());
Verifier.checkResponse(response);
@ -65,12 +65,12 @@ public class ContainerService extends ContextAccessor implements ContainerClient
.collect(Collectors.toList());
}
public ContainerId createContainerAsync(Container container) {
public ContainerId createContainer(Container container) {
var grpcContainer = ContainerMapper.toGrpcMessage(container);
grpcContainer = grpcContainer.toBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(context.getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(context.getVersion()))
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()))
.build();
var request = Service.PutRequest.newBuilder()
@ -78,21 +78,21 @@ public class ContainerService extends ContextAccessor implements ContainerClient
Service.PutRequest.Body.newBuilder()
.setContainer(grpcContainer)
.setSignature(
signRFC6979(context.getPublicKey(), context.getPrivateKey(), grpcContainer)
signRFC6979(getContext().getKey(), grpcContainer)
)
.build()
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = containerServiceAsyncClient.put(request.build());
var response = serviceBlockingStub.put(request.build());
Verifier.checkResponse(response);
return ContainerId.fromHash(response.getBody().getContainerId().getValue().toByteArray());
}
public void deleteContainerAsync(ContainerId cid) {
public void deleteContainer(ContainerId cid) {
var grpcContainerId = ContainerIdMapper.toGrpcMessage(cid);
var request = Service.DeleteRequest.newBuilder()
@ -100,15 +100,15 @@ public class ContainerService extends ContextAccessor implements ContainerClient
Service.DeleteRequest.Body.newBuilder()
.setContainerId(grpcContainerId)
.setSignature(signRFC6979(
context.getPublicKey(), context.getPrivateKey(), grpcContainerId.getValue()
getContext().getKey(), grpcContainerId.getValue()
))
.build()
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = containerServiceAsyncClient.delete(request.build());
var response = serviceBlockingStub.delete(request.build());
Verifier.checkResponse(response);
}

28
client/src/main/java/info/FrostFS/sdk/services/impl/NetmapService.java
View file

@ -4,8 +4,8 @@ import frostFS.netmap.NetmapServiceGrpc;
import frostFS.netmap.Service;
import frostFS.netmap.Types;
import info.FrostFS.sdk.Verifier;
import info.FrostFS.sdk.jdo.netmap.NetmapSnapshot;
import info.FrostFS.sdk.jdo.netmap.NodeInfo;
import info.FrostFS.sdk.dto.netmap.NetmapSnapshot;
import info.FrostFS.sdk.dto.netmap.NodeInfo;
import info.FrostFS.sdk.mappers.netmap.NetmapSnapshotMapper;
import info.FrostFS.sdk.mappers.netmap.NodeInfoMapper;
import info.FrostFS.sdk.services.ContextAccessor;
@ -24,7 +24,7 @@ public class NetmapService extends ContextAccessor implements NetmapClient {
public NetmapService(ClientEnvironment clientEnvironment) {
super(clientEnvironment);
this.netmapServiceClient = NetmapServiceGrpc.newBlockingStub(context.getChannel());
this.netmapServiceClient = NetmapServiceGrpc.newBlockingStub(getContext().getChannel());
}
private static boolean getBoolValue(byte[] bytes) {
@ -92,12 +92,12 @@ public class NetmapService extends ContextAccessor implements NetmapClient {
}
@Override
public NetworkSettings getNetworkSettingsAsync() {
if (nonNull(context.getNetworkSettings())) {
return context.getNetworkSettings();
public NetworkSettings getNetworkSettings() {
if (nonNull(getContext().getNetworkSettings())) {
return getContext().getNetworkSettings();
}
var info = getNetworkInfoAsync();
var info = getNetworkInfo();
var settings = new NetworkSettings();
@ -105,18 +105,18 @@ public class NetmapService extends ContextAccessor implements NetmapClient {
setNetworksParam(param, settings);
}
context.setNetworkSettings(settings);
getContext().setNetworkSettings(settings);
return settings;
}
@Override
public NodeInfo getLocalNodeInfoAsync() {
public NodeInfo getLocalNodeInfo() {
var request = Service.LocalNodeInfoRequest.newBuilder()
.setBody(Service.LocalNodeInfoRequest.Body.newBuilder().build());
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = netmapServiceClient.localNodeInfo(request.build());
Verifier.checkResponse(response);
@ -124,12 +124,12 @@ public class NetmapService extends ContextAccessor implements NetmapClient {
return NodeInfoMapper.toModel(response.getBody());
}
public Service.NetworkInfoResponse getNetworkInfoAsync() {
public Service.NetworkInfoResponse getNetworkInfo() {
var request = Service.NetworkInfoRequest.newBuilder()
.setBody(Service.NetworkInfoRequest.Body.newBuilder().build());
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = netmapServiceClient.networkInfo(request.build());
@ -139,12 +139,12 @@ public class NetmapService extends ContextAccessor implements NetmapClient {
}
@Override
public NetmapSnapshot getNetmapSnapshotAsync() {
public NetmapSnapshot getNetmapSnapshot() {
var request = Service.NetmapSnapshotRequest.newBuilder()
.setBody(Service.NetmapSnapshotRequest.Body.newBuilder().build());
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = netmapServiceClient.netmapSnapshot(request.build());

228
client/src/main/java/info/FrostFS/sdk/services/impl/ObjectService.java
View file

@ -6,16 +6,24 @@ import frostFS.object.ObjectServiceGrpc;
import frostFS.object.Service;
import frostFS.refs.Types;
import info.FrostFS.sdk.Verifier;
import info.FrostFS.sdk.jdo.*;
import info.FrostFS.sdk.constants.AppConst;
import info.FrostFS.sdk.dto.container.ContainerId;
import info.FrostFS.sdk.dto.Split;
import info.FrostFS.sdk.dto.object.*;
import info.FrostFS.sdk.mappers.*;
import info.FrostFS.sdk.mappers.container.ContainerIdMapper;
import info.FrostFS.sdk.mappers.object.ObjectFilterMapper;
import info.FrostFS.sdk.mappers.object.ObjectHeaderMapper;
import info.FrostFS.sdk.mappers.object.ObjectIdMapper;
import info.FrostFS.sdk.mappers.object.ObjectFrostFSMapper;
import info.FrostFS.sdk.services.ContextAccessor;
import info.FrostFS.sdk.services.ObjectClient;
import info.FrostFS.sdk.tools.ClientEnvironment;
import info.FrostFS.sdk.tools.PutObjectParameters;
import org.apache.commons.collections4.CollectionUtils;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -29,15 +37,17 @@ import static java.util.Objects.nonNull;
public class ObjectService extends ContextAccessor implements ObjectClient {
private final ObjectServiceGrpc.ObjectServiceBlockingStub objectServiceBlockingClient;
private final ObjectServiceGrpc.ObjectServiceStub objectServiceClient;
private final ObjectTools objectTools;
public ObjectService(ClientEnvironment clientEnvironment) {
super(clientEnvironment);
this.objectServiceBlockingClient = ObjectServiceGrpc.newBlockingStub(context.getChannel());
this.objectServiceClient = ObjectServiceGrpc.newStub(context.getChannel());
this.objectServiceBlockingClient = ObjectServiceGrpc.newBlockingStub(getContext().getChannel());
this.objectServiceClient = ObjectServiceGrpc.newStub(getContext().getChannel());
this.objectTools = new ObjectTools(clientEnvironment);
}
@Override
public ObjectHeader getObjectHeadAsync(ContainerId cid, ObjectId oid) {
public ObjectHeader getObjectHead(ContainerId cid, ObjectId oid) {
var request = Service.HeadRequest.newBuilder()
.setBody(
Service.HeadRequest.Body.newBuilder()
@ -50,7 +60,7 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = objectServiceBlockingClient.head(request.build());
Verifier.checkResponse(response);
@ -59,8 +69,8 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
}
@Override
public ObjectFrostFs getObjectAsync(ContainerId cid, ObjectId oid) {
var sessionToken = context.getFrostFSClient().createSessionInternalAsync(-1);
public ObjectFrostFS getObject(ContainerId cid, ObjectId oid) {
var sessionToken = getContext().getFrostFSClient().createSessionInternal(-1);
var request = Service.GetRequest.newBuilder()
.setBody(
@ -71,24 +81,23 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
.setObjectId(ObjectIdMapper.toGrpcMessage(oid))
.build()
)
.setRaw(false)
.build()
);
addMetaHeader(request);
addObjectSessionToken(
request, sessionToken, ContainerIdMapper.toGrpcMessage(cid), ObjectIdMapper.toGrpcMessage(oid),
frostFS.session.Types.ObjectSessionContext.Verb.GET, context.getPublicKey(), context.getPrivateKey()
frostFS.session.Types.ObjectSessionContext.Verb.GET, getContext().getKey()
);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var obj = getObject(request.build());
return ObjectMapper.toModel(obj);
return ObjectFrostFSMapper.toModel(obj);
}
@Override
public void deleteObjectAsync(ContainerId cid, ObjectId oid) {
public void deleteObject(ContainerId cid, ObjectId oid) {
var request = Service.DeleteRequest.newBuilder()
.setBody(
Service.DeleteRequest.Body.newBuilder()
@ -101,27 +110,17 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
.build());
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var response = objectServiceBlockingClient.delete(request.build());
Verifier.checkResponse(response);
}
@Override
public ObjectId putObjectAsync(ObjectHeader header, FileInputStream payload) {
return putObject(header, payload);
}
@Override
public ObjectId putObjectAsync(ObjectHeader header, byte[] payload) {
return putObject(header, new ByteArrayInputStream(payload));
}
@Override
public Iterable<ObjectId> searchObjectsAsync(ContainerId cid, ObjectFilter... filters) {
public Iterable<ObjectId> searchObjects(ContainerId cid, ObjectFilter... filters) {
var body = Service.SearchRequest.Body.newBuilder()
.setContainerId(ContainerIdMapper.toGrpcMessage(cid))
.setVersion(1);
.setVersion(1);// TODO: clarify this param
for (ObjectFilter filter : filters) {
body.addFilters(ObjectFilterMapper.toGrpcMessage(filter));
@ -131,13 +130,43 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
.setBody(body.build());
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
var objectsIds = searchObjects(request.build());
return Iterables.transform(objectsIds, input -> ObjectId.fromHash(input.getValue().toByteArray()));
}
@Override
public ObjectId putObject(PutObjectParameters parameters) {
parameters.validate();
return parameters.clientCut ? putClientCutObject(parameters) : putStreamObject(parameters);
}
public ObjectId putSingleObject(ObjectFrostFS modelObject) {
var sessionToken = getContext().getFrostFSClient().createSessionInternal(-1);
var grpcObject = objectTools.createObject(modelObject);
var request = Service.PutSingleRequest.newBuilder()
.setBody(Service.PutSingleRequest.Body.newBuilder().setObject(grpcObject).build());
addMetaHeader(request);
addObjectSessionToken(
request, sessionToken, grpcObject.getHeader().getContainerId(), grpcObject.getObjectId(),
frostFS.session.Types.ObjectSessionContext.Verb.PUT, getContext().getKey()
);
sign(request, getContext().getKey());
var response = objectServiceBlockingClient.putSingle(request.build());
Verifier.checkResponse(response);
return ObjectId.fromHash(grpcObject.getObjectId().getValue().toByteArray());
}
private frostFS.object.Types.Object getObject(Service.GetRequest request) {
var iterator = getObjectInit(request);
var obj = iterator.readHeader();
@ -162,18 +191,20 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
return new ObjectReader(objectServiceBlockingClient.get(initRequest));
}
private ObjectId putObject(ObjectHeader header, InputStream payload) {
var sessionToken = context.getFrostFSClient().createSessionInternalAsync(-1);
var hdr = ObjectHeaderMapper.toGrpcMessage(header);
private ObjectId putStreamObject(PutObjectParameters parameters) {
var header = parameters.getHeader();
var sessionToken = getContext().getFrostFSClient().createSessionInternal(-1);
var hdr = ObjectHeaderMapper.toGrpcMessage(header);
hdr = hdr.toBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(context.getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(context.getVersion()))
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()))
.build();
var oid = Types.ObjectID.newBuilder().setValue(getSha256(hdr)).build();
var request = Service.PutRequest.newBuilder()
var initRequest = Service.PutRequest.newBuilder()
.setBody(
Service.PutRequest.Body.newBuilder()
.setInit(
@ -181,34 +212,35 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
).build()
);
addMetaHeader(request);
addMetaHeader(initRequest);
addObjectSessionToken(
request, sessionToken, hdr.getContainerId(), oid, frostFS.session.Types.ObjectSessionContext.Verb.PUT,
context.getPublicKey(), context.getPrivateKey()
initRequest, sessionToken, hdr.getContainerId(), oid,
frostFS.session.Types.ObjectSessionContext.Verb.PUT, getContext().getKey()
);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(initRequest, getContext().getKey());
var writer = putObjectInit(request.build());
var writer = putObjectInit(initRequest.build());
var buffer = new byte[Constants.OBJECT_CHUNK_SIZE];
int bufferLength = 0;
try {
bufferLength = payload.readNBytes(buffer, 0, Constants.OBJECT_CHUNK_SIZE);
while (bufferLength > 0) {
request.setBody(
Service.PutRequest.Body.newBuilder()
.setChunk(ByteString.copyFrom(Arrays.copyOfRange(buffer, 0, bufferLength)))
.build()
)
.clearVerifyHeader();
sign(request, context.getPublicKey(), context.getPrivateKey());
writer.write(request.build());
bufferLength = payload.readNBytes(buffer, 0, Constants.OBJECT_CHUNK_SIZE);
}
} catch (
IOException e) {
throw new RuntimeException(e);
var bufferSize = parameters.getBufferMaxSize() > 0 ? parameters.getBufferMaxSize() : AppConst.OBJECT_CHUNK_SIZE;
bufferSize = (int) Math.min(getStreamSize(parameters.getPayload()), bufferSize);
bufferSize = header.getPayloadLength() > 0 ? (int) Math.min(header.getPayloadLength(), bufferSize) : bufferSize;
var buffer = new byte[bufferSize];
while (true) {
var bytesCount = readNBytes(parameters.getPayload(), buffer, bufferSize);
if (bytesCount <= 0)
break;
var chunkRequest = Service.PutRequest.newBuilder(initRequest.build())
.setBody(
Service.PutRequest.Body.newBuilder()
.setChunk(ByteString.copyFrom(Arrays.copyOfRange(buffer, 0, bytesCount)))
.build()
)
.clearVerifyHeader();
sign(chunkRequest, getContext().getKey());
writer.write(chunkRequest.build());
}
var response = writer.complete();
@ -217,6 +249,71 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
return ObjectId.fromHash(response.getBody().getObjectId().getValue().toByteArray());
}
private ObjectId putClientCutObject(PutObjectParameters parameters) {
var header = parameters.getHeader();
var networkSettings = getContext().getFrostFSClient().getNetworkSettings();
var payloadSize = getStreamSize(parameters.getPayload());
var objectSize = (int) Math.min(payloadSize, networkSettings.getMaxObjectSize());
var fullLength = header.getPayloadLength() == 0 ? payloadSize : header.getPayloadLength();
if (fullLength == 0) {
throw new IllegalArgumentException("Payload stream must be able to seek or PayloadLength must be specified");
}
var buffer = new byte[objectSize];
var largeObject = new LargeObject(header.getContainerId());
var split = new Split();
ObjectId objectId;
List<ObjectId> sentObjectIds = new ArrayList<>();
ObjectFrostFS currentObject;
while (true) {
var bytesCount = readNBytes(parameters.getPayload(), buffer, objectSize);
if (CollectionUtils.isNotEmpty(sentObjectIds)) {
split.setPrevious(sentObjectIds.get(sentObjectIds.size() - 1));
}
largeObject.appendBlock(buffer, bytesCount);
currentObject = new ObjectFrostFS(
header.getContainerId(),
bytesCount < objectSize ? Arrays.copyOfRange(buffer, 0, bytesCount) : buffer
);
currentObject.setSplit(split);
if (largeObject.getPayloadLength() == fullLength)
break;
objectId = putSingleObject(currentObject);
sentObjectIds.add(objectId);
}
if (CollectionUtils.isEmpty(sentObjectIds)) {
currentObject.addAttributes(parameters.getHeader().getAttributes());
return putSingleObject(currentObject);
}
largeObject.addAttributes(parameters.getHeader().getAttributes());
largeObject.calculateHash();
currentObject.setParent(largeObject);
objectId = putSingleObject(currentObject);
sentObjectIds.add(objectId);
var linkObject = new LinkObject(header.getContainerId(), split.getSplitId(), largeObject);
linkObject.addChildren(sentObjectIds);
linkObject.getHeader().getAttributes().clear();
putSingleObject(linkObject);
return objectTools.calculateObjectId(largeObject.getHeader());
}
private ObjectWriter putObjectInit(Service.PutRequest initRequest) {
if (initRequest.getSerializedSize() == 0) {
throw new IllegalArgumentException(initRequest.getClass().getName());
@ -248,4 +345,19 @@ public class ObjectService extends ContextAccessor implements ObjectClient {
return new SearchReader(objectServiceBlockingClient.search(initRequest));
}
private int readNBytes(FileInputStream fileInputStream, byte[] buffer, int size) {
try {
return fileInputStream.readNBytes(buffer, 0, size);
} catch (IOException exp) {
throw new IllegalArgumentException(exp.getMessage());
}
}
private long getStreamSize(FileInputStream fileInputStream) {
try {
return fileInputStream.getChannel().size();
} catch (IOException exp) {
throw new IllegalArgumentException(exp.getMessage());
}
}
}

106
client/src/main/java/info/FrostFS/sdk/services/impl/ObjectTools.java Normal file
View file

@ -0,0 +1,106 @@
package info.FrostFS.sdk.services.impl;
import com.google.protobuf.ByteString;
import frostFS.object.Types;
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.mappers.object.ObjectHeaderMapper;
import info.FrostFS.sdk.mappers.object.ObjectIdMapper;
import info.FrostFS.sdk.mappers.OwnerIdMapper;
import info.FrostFS.sdk.mappers.VersionMapper;
import info.FrostFS.sdk.services.ContextAccessor;
import info.FrostFS.sdk.services.ToolsClient;
import info.FrostFS.sdk.tools.ClientEnvironment;
import org.apache.commons.collections4.ListUtils;
import static info.FrostFS.sdk.Helper.getSha256;
import static info.FrostFS.sdk.RequestSigner.signData;
import static java.util.Objects.nonNull;
public class ObjectTools extends ContextAccessor implements ToolsClient {
public ObjectTools(ClientEnvironment context) {
super(context);
}
private static frostFS.refs.Types.Checksum sha256Checksum(byte[] data) {
return frostFS.refs.Types.Checksum.newBuilder()
.setType(frostFS.refs.Types.ChecksumType.SHA256)
.setSum(ByteString.copyFrom(getSha256(data)))
.build();
}
@Override
public ObjectId calculateObjectId(ObjectHeader header) {
var grpcHeader = createHeader(header, new byte[]{});
return ObjectIdMapper.toModel(
frostFS.refs.Types.ObjectID.newBuilder().setValue(getSha256(grpcHeader)).build()
);
}
public Types.Object createObject(ObjectFrostFS objectFrostFs) {
var grpcHeaderBuilder = ObjectHeaderMapper.toGrpcMessage(objectFrostFs.getHeader()).toBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()))
.setPayloadLength(objectFrostFs.getPayload().length)
.setPayloadHash(sha256Checksum(objectFrostFs.getPayload()));
var split = objectFrostFs.getHeader().getSplit();
if (nonNull(split)) {
var splitGrpc = Types.Header.Split.newBuilder()
.setSplitId(nonNull(split.getSplitId()) ? ByteString.copyFrom(split.getSplitId().toBinary()) : null);
ListUtils.emptyIfNull(split.getChildren()).stream()
.map(ObjectIdMapper::toGrpcMessage)
.forEach(splitGrpc::addChildren);
if (nonNull(split.getParentHeader())) {
var grpcParentHeader = createHeader(split.getParentHeader(), new byte[]{});
var parent = frostFS.refs.Types.ObjectID.newBuilder().setValue(getSha256(grpcParentHeader)).build();
splitGrpc
.setParent(parent)
.setParentHeader(grpcParentHeader)
.setParentSignature(
frostFS.refs.Types.Signature.newBuilder()
.setKey(ByteString.copyFrom(getContext().getKey().getPublicKeyByte()))
.setSign(ByteString.copyFrom(signData(getContext().getKey(), parent.toByteArray())))
);
split.setParent(ObjectIdMapper.toModel(parent));
}
if (nonNull(split.getPrevious())) {
splitGrpc.setPrevious(ObjectIdMapper.toGrpcMessage(split.getPrevious()));
}
grpcHeaderBuilder.setSplit(splitGrpc);
}
var grpcHeader = grpcHeaderBuilder.build();
var objectId = frostFS.refs.Types.ObjectID.newBuilder().setValue(getSha256(grpcHeader)).build();
return Types.Object.newBuilder()
.setHeader(grpcHeader)
.setObjectId(objectId)
.setPayload(ByteString.copyFrom(objectFrostFs.getPayload()))
.setSignature(
frostFS.refs.Types.Signature.newBuilder()
.setKey(ByteString.copyFrom(getContext().getKey().getPublicKeyByte()))
.setSign(ByteString.copyFrom(signData(getContext().getKey(), objectId.toByteArray())))
)
.build();
}
private Types.Header createHeader(ObjectHeader header, byte[] payload) {
var grpcHeader = ObjectHeaderMapper.toGrpcMessage(header).toBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()));
if (header.getPayloadCheckSum() != null)
grpcHeader.setPayloadHash(sha256Checksum(header.getPayloadCheckSum()));
else if (payload != null)
grpcHeader.setPayloadHash(sha256Checksum(payload));
return grpcHeader.build();
}
}

18
client/src/main/java/info/FrostFS/sdk/services/impl/SessionService.java
View file

@ -3,7 +3,7 @@ package info.FrostFS.sdk.services.impl;
import frostFS.session.Service;
import frostFS.session.SessionServiceGrpc;
import frostFS.session.Types;
import info.FrostFS.sdk.jdo.SessionToken;
import info.FrostFS.sdk.dto.SessionToken;
import info.FrostFS.sdk.mappers.OwnerIdMapper;
import info.FrostFS.sdk.mappers.SessionMapper;
import info.FrostFS.sdk.services.ContextAccessor;
@ -14,36 +14,36 @@ import static info.FrostFS.sdk.RequestConstructor.addMetaHeader;
import static info.FrostFS.sdk.RequestSigner.sign;
public class SessionService extends ContextAccessor implements SessionClient {
private final SessionServiceGrpc.SessionServiceBlockingStub sessionServiceAsyncClient;
private final SessionServiceGrpc.SessionServiceBlockingStub serviceBlockingStub;
public SessionService(ClientEnvironment clientEnvironment) {
super(clientEnvironment);
this.sessionServiceAsyncClient = SessionServiceGrpc.newBlockingStub(context.getChannel());
this.serviceBlockingStub = SessionServiceGrpc.newBlockingStub(getContext().getChannel());
}
@Override
public SessionToken createSessionAsync(long expiration) {
var sessionToken = createSessionInternalAsync(expiration);
public SessionToken createSession(long expiration) {
var sessionToken = createSessionInternal(expiration);
var token = SessionMapper.serialize(sessionToken);
return new SessionToken(new byte[]{}, token);
}
public Types.SessionToken createSessionInternalAsync(long expiration) {
public Types.SessionToken createSessionInternal(long expiration) {
var request = Service.CreateRequest.newBuilder()
.setBody(
Service.CreateRequest.Body.newBuilder()
.setOwnerId(OwnerIdMapper.toGrpcMessage(context.getOwnerId()))
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setExpiration(expiration).build()
);
addMetaHeader(request);
sign(request, context.getPublicKey(), context.getPrivateKey());
sign(request, getContext().getKey());
return createSession(request.build());
}
private Types.SessionToken createSession(Service.CreateRequest request) {
var resp = sessionServiceAsyncClient.create(request);
var resp = serviceBlockingStub.create(request);
var lifetime = Types.SessionToken.Body.TokenLifetime.newBuilder()
.setExp(request.getBody().getExpiration())

25
client/src/main/java/info/FrostFS/sdk/tools/ClientEnvironment.java
View file

@ -1,26 +1,21 @@
package info.FrostFS.sdk.tools;
import info.FrostFS.sdk.jdo.OwnerId;
import info.FrostFS.sdk.jdo.Version;
import info.FrostFS.sdk.dto.OwnerId;
import info.FrostFS.sdk.dto.Version;
import info.FrostFS.sdk.services.FrostFSClient;
import io.grpc.Channel;
import static info.FrostFS.sdk.KeyExtension.getPrivateKeyFromWIF;
import static info.FrostFS.sdk.KeyExtension.loadPublicKey;
public class ClientEnvironment {
private final OwnerId ownerId;
private final Version version;
private final byte[] privateKey;
private final byte[] publicKey;
private final ECDsa key;
private final Channel channel;
private final FrostFSClient frostFSClient;
private NetworkSettings networkSettings;
public ClientEnvironment(String key, Channel channel, Version version, FrostFSClient frostFSClient) {
this.privateKey = getPrivateKeyFromWIF(key);
this.publicKey = loadPublicKey(privateKey);
this.ownerId = OwnerId.fromKey(publicKey);
public ClientEnvironment(String wif, Channel channel, Version version, FrostFSClient frostFSClient) {
this.key = new ECDsa(wif);
this.ownerId = OwnerId.fromKey(key.getPublicKeyByte());
this.version = version;
this.channel = channel;
this.frostFSClient = frostFSClient;
@ -50,11 +45,7 @@ public class ClientEnvironment {
return version;
}
public byte[] getPrivateKey() {
return privateKey;
}
public byte[] getPublicKey() {
return publicKey;
public ECDsa getKey() {
return key;
}
}

2
client/src/main/java/info/FrostFS/sdk/ClientSettings.java → client/src/main/java/info/FrostFS/sdk/tools/ClientSettings.java
View file

@ -1,4 +1,4 @@
package info.FrostFS.sdk;
package info.FrostFS.sdk.tools;
import io.grpc.ChannelCredentials;
import org.apache.commons.lang3.StringUtils;

29
client/src/main/java/info/FrostFS/sdk/tools/ECDsa.java Normal file
View file

@ -0,0 +1,29 @@
package info.FrostFS.sdk.tools;
import java.security.PrivateKey;
import static info.FrostFS.sdk.KeyExtension.*;
public class ECDsa {
private final byte[] publicKeyByte;
private final byte[] privateKeyByte;
private final PrivateKey privateKey;
public ECDsa(String wif) {
this.privateKeyByte = getPrivateKeyFromWIF(wif);
this.publicKeyByte = loadPublicKey(privateKeyByte);
this.privateKey = loadPrivateKey(privateKeyByte);
}
public byte[] getPublicKeyByte() {
return publicKeyByte;
}
public byte[] getPrivateKeyByte() {
return privateKeyByte;
}
public PrivateKey getPrivateKey() {
return privateKey;
}
}

76
client/src/main/java/info/FrostFS/sdk/tools/PutObjectParameters.java Normal file
View file

@ -0,0 +1,76 @@
package info.FrostFS.sdk.tools;
import info.FrostFS.sdk.dto.object.ObjectHeader;
import java.io.FileInputStream;
import static java.util.Objects.isNull;
public class PutObjectParameters {
private static final String ERROR_TEMPLATE = "%s value cannot be null.";
public ObjectHeader header;
public FileInputStream payload;
public boolean clientCut;
public int bufferMaxSize;
public PutObjectParameters(ObjectHeader header, FileInputStream payload, boolean clientCut, int bufferMaxSize) {
this.header = header;
this.payload = payload;
this.clientCut = clientCut;
this.bufferMaxSize = bufferMaxSize;
}
public PutObjectParameters(ObjectHeader header, FileInputStream payload) {
this.header = header;
this.payload = payload;
}
public ObjectHeader getHeader() {
return header;
}
public void setHeader(ObjectHeader header) {
this.header = header;
}
public FileInputStream getPayload() {
return payload;
}
public void setPayload(FileInputStream payload) {
this.payload = payload;
}
public boolean isClientCut() {
return clientCut;
}
public void setClientCut(boolean clientCut) {
this.clientCut = clientCut;
}
public int getBufferMaxSize() {
return bufferMaxSize;
}
public void setBufferMaxSize(int bufferMaxSize) {
this.bufferMaxSize = bufferMaxSize;
}
public void validate() {
StringBuilder errorMessage = new StringBuilder();
if (isNull(header)) {
errorMessage.append(String.format(ERROR_TEMPLATE, "Header")).append(System.lineSeparator());
}
if (isNull(payload)) {
errorMessage.append(String.format(ERROR_TEMPLATE, "Payload")).append(System.lineSeparator());
}
if (errorMessage.length() != 0) {
throw new IllegalArgumentException(errorMessage.toString());
}
}
}