Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.storage;

import com.amazonaws.ClientConfiguration;

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.ObjectMetadata;

import com.amazonaws.services.s3.model.S3Object;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;

import java.io.InputStream;

/**

 * S3-compatible object storage, added for LMS call-recording retention (SOP §17 — 24 months).

 *

 * <p>The app's existing file store ({@code dtr.document} + {@code new File(path + name)}) is local

 * disk, which does not carry the volume recordings imply (~1 MB/min of stereo audio) and does not

 * survive a multi-node deploy. This service is deliberately generic rather than recording-specific

 * so other bulk artefacts can move off local disk later.

 *

 * <p>Works against AWS S3 or any S3-compatible endpoint (MinIO, Wasabi, DO Spaces): leave

 * {@code endpoint} blank for real AWS, or set it plus {@code pathStyle=true} for the others.

 *

 * <p>The client is built lazily and the service reports {@link #isEnabled()} rather than throwing at

 * startup — an unconfigured store must not stop the app from booting, it must only stop the archival

 * worker from claiming it stored anything.

 */

@Service

public class ObjectStoreService {

    private static final Logger LOGGER = LogManager.getLogger(ObjectStoreService.class);

    @Value("${lms.recording.store.enabled:false}")

    private boolean enabled;

    /** Blank for real AWS; set for MinIO/Wasabi/Spaces. */

    @Value("${lms.recording.store.endpoint:}")

    private String endpoint;

    @Value("${lms.recording.store.region:ap-south-1}")

    private String region;

    @Value("${lms.recording.store.bucket:}")

    private String bucket;

    @Value("${lms.recording.store.accessKey:}")

    private String accessKey;

    @Value("${lms.recording.store.secretKey:}")

    private String secretKey;

    /** Non-AWS S3 implementations generally need path-style addressing. */

    @Value("${lms.recording.store.pathStyle:true}")

    private boolean pathStyle;

    private volatile AmazonS3 client;

    /** False when the store is switched off or half-configured — callers must not assume a write. */

    public boolean isEnabled() {

        return enabled

                && bucket != null && !bucket.trim().isEmpty()

                && accessKey != null && !accessKey.trim().isEmpty()

                && secretKey != null && !secretKey.trim().isEmpty();

    }

    public String getBucket() {

        return bucket;

    }

    /**

     * Store an object. {@code contentLength} must be accurate — S3 streams without buffering the

     * whole body, and a wrong length is a corrupt upload rather than an error.

     *

     * @return the key it was stored under, for persisting alongside the row that owns it

     */

    public String put(String key, InputStream content, long contentLength, String contentType) {

        requireEnabled();

        ObjectMetadata metadata = new ObjectMetadata();

        metadata.setContentLength(contentLength);

        if (contentType != null && !contentType.trim().isEmpty()) {

            metadata.setContentType(contentType);

        }

        client().putObject(bucket, key, content, metadata);

        LOGGER.info("Stored object {} ({} bytes) in bucket {}", key, contentLength, bucket);

        return key;

    }

    /**

     * Open an object for reading. The caller owns the stream and MUST close it — an unclosed S3

     * object holds a connection out of the pool until it times out.

     */

    public S3Object get(String key) {

        requireEnabled();

        return client().getObject(bucket, key);

    }

    public boolean exists(String key) {

        if (!isEnabled()) {

            return false;

        }

        try {

            return client().doesObjectExist(bucket, key);

        } catch (Exception e) {

            LOGGER.warn("Could not check object {} in bucket {}", key, bucket, e);

            return false;

        }

    }

    public void delete(String key) {

        requireEnabled();

        client().deleteObject(bucket, key);

    }

    private void requireEnabled() {

        if (!isEnabled()) {

            throw new IllegalStateException(

                    "Object store is not configured — set lms.recording.store.{enabled,bucket,accessKey,secretKey}");

        }

    }

    /** Double-checked lazy build so a bad config surfaces on first use, not at context startup. */

    private AmazonS3 client() {

        AmazonS3 local = client;

        if (local == null) {

            synchronized (this) {

                local = client;

                if (local == null) {

                    local = build();

                    client = local;

                }

            }

        }

        return local;

    }

    private AmazonS3 build() {

        ClientConfiguration config = new ClientConfiguration();

        config.setConnectionTimeout(5000);

        // Recordings are a few MB; generous enough for a slow link, bounded enough that the

        // archival worker cannot wedge on a hanging endpoint.

        config.setSocketTimeout(60000);

        AmazonS3ClientBuilder builder = AmazonS3ClientBuilder.standard()

                .withCredentials(new AWSStaticCredentialsProvider(

                        new BasicAWSCredentials(accessKey.trim(), secretKey.trim())))

                .withClientConfiguration(config);

        if (endpoint != null && !endpoint.trim().isEmpty()) {

            builder = builder

                    .withEndpointConfiguration(

                            new AwsClientBuilder.EndpointConfiguration(endpoint.trim(), region))

                    .withPathStyleAccessEnabled(pathStyle);

        } else {

            builder = builder.withRegion(region);

        }

        LOGGER.info("Object store client built for bucket {} (endpoint={})", bucket,

                endpoint == null || endpoint.trim().isEmpty() ? "aws" : endpoint);

        return builder.build();

    }

}