Renamed file(datasafe-examples): Renamed BaseUserOperationsWithDefaul…

…tDatasafeOnVersionedStorageTest file to BaseUserOperationsWithDefaultDatasafeOnVersionedStorageIT since it contains an integration test

datasafe-examples/datasafe-examples-versioned-s3/src/test/java/de/adorsys/datasafe/examples/business/s3/BaseUserOperationsWithDefaultDatasafeOnVersionedStorageIT.java

@@ -0,0 +1,247 @@
+package de.adorsys.datasafe.examples.business.s3;
+
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.client.builder.AwsClientBuilder;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import com.amazonaws.services.s3.model.AmazonS3Exception;
+import com.amazonaws.services.s3.model.BucketVersioningConfiguration;
+import com.amazonaws.services.s3.model.SetBucketVersioningConfigurationRequest;
+import de.adorsys.datasafe.business.impl.service.DaggerDefaultDatasafeServices;
+import de.adorsys.datasafe.business.impl.service.DefaultDatasafeServices;
+import de.adorsys.datasafe.directory.impl.profile.config.DefaultDFSConfig;
+import de.adorsys.datasafe.encrypiton.api.types.UserIDAuth;
+import de.adorsys.datasafe.storage.impl.s3.S3StorageService;
+import de.adorsys.datasafe.types.api.actions.ListRequest;
+import de.adorsys.datasafe.types.api.actions.ReadRequest;
+import de.adorsys.datasafe.types.api.actions.RemoveRequest;
+import de.adorsys.datasafe.types.api.actions.WriteRequest;
+import de.adorsys.datasafe.types.api.callback.PhysicalVersionCallback;
+import de.adorsys.datasafe.types.api.resource.StorageVersion;
+import de.adorsys.datasafe.types.api.utils.ExecutorServiceUtil;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIfSystemProperty;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * This test shows simplistic usage of Datasafe default services that reside on versioned storage system.
+ */
+@Slf4j
+@DisabledIfSystemProperty(named = "SKIP_CEPH", matches = "true")
+class BaseUserOperationsWithDefaultDatasafeOnVersionedStorageTest {
+
+    private static final String MY_OWN_FILE_TXT = "my/own/file.txt";
+
+    private static final String VERSIONED_BUCKET_NAME = "home";
+    private static final String ACCESS_KEY = "access";
+    private static final String SECRET_KEY = "secret";
+
+    private static GenericContainer cephContainer;
+    private static AmazonS3 cephS3;
+    private static String cephMappedUrl;
+
+    private DefaultDatasafeServices defaultDatasafeServices;
+
+    /**
+     * This creates CEPH Rados gateway in docker container and creates S3 client for it.
+     */
+    @BeforeAll
+    static void createServices() {
+        log.info("Starting CEPH");
+        // Create CEPH container:
+        cephContainer = new GenericContainer("ceph/daemon")
+                .withExposedPorts(8000, 5000)
+                .withEnv("RGW_FRONTEND_PORT", "8000")
+                .withEnv("SREE_PORT", "5000")
+                .withEnv("DEBUG", "verbose")
+                .withEnv("CEPH_DEMO_UID", "nano")
+                .withEnv("MON_IP", "127.0.0.1")
+                .withEnv("CEPH_PUBLIC_NETWORK", "0.0.0.0/0")
+                .withEnv("CEPH_DAEMON", "demo")
+                .withEnv("DEMO_DAEMONS", "mon,mgr,osd,rgw")
+                .withEnv("CEPH_DEMO_ACCESS_KEY", ACCESS_KEY)
+                .withEnv("CEPH_DEMO_SECRET_KEY", SECRET_KEY)
+                .withCommand("mkdir -p /etc/ceph && mkdir -p /var/lib/ceph && /entrypoint.sh")
+                .waitingFor(Wait.defaultWaitStrategy());
+
+        cephContainer.start();
+        Integer mappedPort = cephContainer.getMappedPort(8000);
+        // URL for S3 API/bucket root:
+        cephMappedUrl = getDockerUri("http://0.0.0.0") + ":" + mappedPort;
+        log.info("Ceph mapped URL: {}", cephMappedUrl);
+        cephS3 = AmazonS3ClientBuilder.standard()
+                .withEndpointConfiguration(
+                        new AwsClientBuilder.EndpointConfiguration(cephMappedUrl, "us-east-1")
+                )
+                .withCredentials(
+                        new AWSStaticCredentialsProvider(
+                                new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY)
+                        )
+                )
+                .enablePathStyleAccess()
+                .build();
+
+        // Create bucket in CEPH that will support versioning
+        cephS3.createBucket(VERSIONED_BUCKET_NAME);
+        cephS3.setBucketVersioningConfiguration(
+                new SetBucketVersioningConfigurationRequest(
+                        VERSIONED_BUCKET_NAME,
+                        new BucketVersioningConfiguration(BucketVersioningConfiguration.ENABLED)
+                )
+        );
+
+
+    }
+
+    @AfterAll
+    static void stopCeph() {
+        cephContainer.stop();
+    }
+
+    @BeforeEach
+    void init() {
+        // this will create all Datasafe files and user documents under S3 bucket root, we assume that
+        // S3 versioned bucket was already created
+        defaultDatasafeServices = DaggerDefaultDatasafeServices.builder()
+                .config(new DefaultDFSConfig(cephMappedUrl, "secret"::toCharArray))
+                .storage(new S3StorageService(
+                        cephS3,
+                        VERSIONED_BUCKET_NAME,
+                        ExecutorServiceUtil.submitterExecutesOnStarvationExecutingService()))
+                .build();
+    }
+
+    /**
+     * S3 storage adapter supports sending back file version (if S3 storage returns it) when storing object to
+     * bucket and it allows reading object using its version too.
+     */
+    @Test
+    @SneakyThrows
+    void writeFileThenReadLatestAndReadByVersion() {
+        // BEGIN_SNIPPET:Versioned storage support - writing file and reading back
+        // creating new user
+        UserIDAuth user = registerUser("john");
+
+        // writing data to my/own/file.txt 3 times with different content:
+        // 1st time, writing into my/own/file.txt:
+        // Expanded snippet of how to capture file version when writing object:
+        AtomicReference<String> version = new AtomicReference<>();
+        try (OutputStream os = defaultDatasafeServices.privateService()
+                .write(WriteRequest.forDefaultPrivate(user, MY_OWN_FILE_TXT)
+                        .toBuilder()
+                        .callback((PhysicalVersionCallback) version::set)
+                        .build())
+        ) {
+            // Initial version will contain "Hello 1":
+            os.write("Hello 1".getBytes(StandardCharsets.UTF_8));
+        }
+        // this variable has our initial file version:
+        String version1 = version.get();
+
+        // Write 2 more times different data to same file - my/own/file.txt:
+        String version2 = writeToPrivate(user, MY_OWN_FILE_TXT, "Hello 2");
+        // Last version will contain "Hello 3":
+        String version3 = writeToPrivate(user, MY_OWN_FILE_TXT, "Hello 3");
+
+        // now, when we read file without specifying version - we see latest file content:
+        assertThat(defaultDatasafeServices.privateService().read(
+                ReadRequest.forDefaultPrivate(user, MY_OWN_FILE_TXT))
+        ).hasContent("Hello 3");
+
+        // but if we specify file version - we get content for it:
+        assertThat(defaultDatasafeServices.privateService().read(
+                ReadRequest.forDefaultPrivateWithVersion(user, MY_OWN_FILE_TXT, new StorageVersion(version1)))
+        ).hasContent("Hello 1");
+        // END_SNIPPET
+
+        log.debug("version 1 " + version1);
+        log.debug("version 2 " + version2);
+        log.debug("version 3 " + version3);
+        assertThat(defaultDatasafeServices.privateService().list(ListRequest.forDefaultPrivate(user, ""))).hasSize(1);
+        assertThat(version1.equals(version2)).isFalse();
+        assertThat(version1.equals(version3)).isFalse();
+    }
+
+    /**
+     * Example of how to remove specific version id
+     */
+    @Test
+    @SneakyThrows
+    void removeSpecificVersionId() {
+        // BEGIN_SNIPPET:Versioned storage support - removing specific version
+        // creating new user
+        UserIDAuth user = registerUser("john");
+
+        // writing data to my/own/file.txt 2 times with different content:
+        String versionId = writeToPrivate(user, MY_OWN_FILE_TXT, "Hello 1");
+        writeToPrivate(user, MY_OWN_FILE_TXT, "Hello 2");
+
+        // now, we read old file version
+        assertThat(defaultDatasafeServices.privateService().read(
+                ReadRequest.forDefaultPrivateWithVersion(user, MY_OWN_FILE_TXT, new StorageVersion(versionId)))
+        ).hasContent("Hello 1");
+
+        // now, we remove old file version
+        defaultDatasafeServices.privateService().remove(
+                RemoveRequest.forDefaultPrivateWithVersion(user, MY_OWN_FILE_TXT, new StorageVersion(versionId))
+        );
+
+        // it is removed from storage, so when we read it we get exception
+        assertThrows(AmazonS3Exception.class, () -> defaultDatasafeServices.privateService().read(
+                ReadRequest.forDefaultPrivateWithVersion(user, MY_OWN_FILE_TXT, new StorageVersion(versionId)))
+        );
+
+        // but latest file version is still available
+        assertThat(defaultDatasafeServices.privateService().read(
+                ReadRequest.forDefaultPrivate(user, MY_OWN_FILE_TXT))
+        ).hasContent("Hello 2");
+        // END_SNIPPET
+    }
+
+    @SneakyThrows
+    private String writeToPrivate(UserIDAuth user, String path, String fileContent) {
+        AtomicReference<String> version = new AtomicReference<>();
+        try (OutputStream os = defaultDatasafeServices.privateService()
+                .write(WriteRequest.forDefaultPrivate(user, path)
+                        .toBuilder()
+                        .callback((PhysicalVersionCallback) version::set)
+                        .build())
+        ) {
+            os.write(fileContent.getBytes(StandardCharsets.UTF_8));
+        }
+
+        return version.get();
+    }
+
+    private UserIDAuth registerUser(String username) {
+        UserIDAuth creds = new UserIDAuth(username, ("passwrd" + username)::toCharArray);
+        defaultDatasafeServices.userProfile().registerUsingDefaults(creds);
+        return creds;
+    }
+
+    @SneakyThrows
+    private static String getDockerUri(String defaultUri) {
+        String dockerHost = System.getenv("DOCKER_HOST");
+        if (dockerHost == null) {
+            return defaultUri;
+        }
+
+        URI dockerUri = new URI(dockerHost);
+        return "http://" + dockerUri.getHost();
+    }
+}