Examples with S3Metadata com.pspace.ifs.ksan.gw.identity.S3Metadata used on opensource projects

Example 1 with S3Metadata

use of com.pspace.ifs.ksan.gw.identity.S3Metadata in project ksan by infinistor.

the class CompleteMultipartUpload method process.

@Override
public void process() throws GWException {
    logger.info(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_START);
    String bucket = s3Parameter.getBucketName();
    initBucketInfo(bucket);
    String object = s3Parameter.getObjectName();
    S3Bucket s3Bucket = new S3Bucket();
    s3Bucket.setCors(getBucketInfo().getCors());
    s3Bucket.setAccess(getBucketInfo().getAccess());
    s3Parameter.setBucket(s3Bucket);
    GWUtils.checkCors(s3Parameter);
    if (s3Parameter.isPublicAccess() && GWUtils.isIgnorePublicAcls(s3Parameter)) {
        throw new GWException(GWErrorCode.ACCESS_DENIED, s3Parameter);
    }
    DataCompleteMultipartUpload dataCompleteMultipartUpload = new DataCompleteMultipartUpload(s3Parameter);
    dataCompleteMultipartUpload.extract();
    String uploadId = dataCompleteMultipartUpload.getUploadId();
    s3Parameter.setUploadId(uploadId);
    String multipartXml = dataCompleteMultipartUpload.getMultipartXml();
    XmlMapper xmlMapper = new XmlMapper();
    CompleteMultipartUploadRequest completeMultipartUpload = new CompleteMultipartUploadRequest();
    try {
        completeMultipartUpload = xmlMapper.readValue(multipartXml, CompleteMultipartUploadRequest.class);
    } catch (JsonMappingException e) {
        PrintStack.logging(logger, e);
        new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
    } catch (JsonProcessingException e) {
        PrintStack.logging(logger, e);
        new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
    }
    if (completeMultipartUpload.parts == null || completeMultipartUpload.parts.size() == 0) {
        logger.error(GWErrorCode.MALFORMED_X_M_L.getMessage() + GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_PART_NO_EXIST);
        throw new GWException(GWErrorCode.MALFORMED_X_M_L, s3Parameter);
    }
    SortedMap<Integer, Part> xmlListPart = new TreeMap<Integer, Part>();
    for (CompleteMultipartUploadRequest.Part sPart : completeMultipartUpload.parts) {
        Part op = new Part();
        op.setPartETag(sPart.eTag);
        op.setPartNumber(sPart.partNumber);
        xmlListPart.put(sPart.partNumber, op);
    }
    SortedMap<Integer, Part> listPart = null;
    ObjMultipart objMultipart = null;
    try {
        objMultipart = new ObjMultipart(bucket);
        listPart = objMultipart.getParts(uploadId);
    } catch (UnknownHostException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
    } catch (Exception e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
    }
    logger.info(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_XML_PARTS_SIZE, completeMultipartUpload.parts.size());
    logger.info(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_PARTS_SIZE, listPart.size());
    if (completeMultipartUpload.parts.size() > listPart.size()) {
        logger.warn(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_LESS_THAN);
        throw new GWException(GWErrorCode.INVALID_PART, s3Parameter);
    } else if (completeMultipartUpload.parts.size() < listPart.size()) {
        logger.warn(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_GREATER_THAN);
        throw new GWException(GWErrorCode.INVALID_PART, s3Parameter);
    }
    for (Iterator<Map.Entry<Integer, Part>> it = xmlListPart.entrySet().iterator(); it.hasNext(); ) {
        Map.Entry<Integer, Part> entry = it.next();
        String eTag = entry.getValue().getPartETag().replace(GWConstants.DOUBLE_QUOTE, "");
        if (listPart.containsKey(entry.getKey())) {
            if (eTag.compareTo(listPart.get(entry.getKey()).getPartETag()) == 0) {
                if (listPart.get(entry.getKey()).getPartSize() < GWConstants.PARTS_MIN_SIZE && entry.getKey() < listPart.size()) {
                    logger.error(GWErrorCode.ENTITY_TOO_SMALL.getMessage());
                    throw new GWException(GWErrorCode.ENTITY_TOO_SMALL, s3Parameter);
                }
            } else {
                throw new GWException(GWErrorCode.INVALID_PART, s3Parameter);
            }
        } else {
            throw new GWException(GWErrorCode.INVALID_PART, s3Parameter);
        }
    }
    // get Acl, Meta data
    Multipart multipart = null;
    try {
        objMultipart = new ObjMultipart(bucket);
        multipart = objMultipart.getMultipart(uploadId);
        if (multipart == null) {
            logger.error(GWConstants.LOG_UPLOAD_NOT_FOUND, uploadId);
            throw new GWException(GWErrorCode.NO_SUCH_UPLOAD, s3Parameter);
        }
    } catch (UnknownHostException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    } catch (Exception e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    String acl = multipart.getAcl();
    String meta = multipart.getMeta();
    // check bucket versioning, and set versionId
    String versioningStatus = getBucketVersioning(bucket);
    String versionId = null;
    Metadata objMeta = null;
    try {
        // check exist object
        objMeta = open(bucket, object);
        if (GWConstants.VERSIONING_ENABLED.equalsIgnoreCase(versioningStatus)) {
            versionId = String.valueOf(System.nanoTime());
        } else {
            versionId = GWConstants.VERSIONING_DISABLE_TAIL;
        }
    } catch (GWException e) {
        logger.info(e.getMessage());
        objMeta = createLocal(bucket, object);
        if (GWConstants.VERSIONING_ENABLED.equalsIgnoreCase(versioningStatus)) {
            versionId = String.valueOf(System.nanoTime());
        } else {
            versionId = GWConstants.VERSIONING_DISABLE_TAIL;
        }
    }
    if (GWConstants.VERSIONING_ENABLED.equalsIgnoreCase(versioningStatus)) {
        logger.info(GWConstants.LOG_COMPLETE_MULTIPART_VERSION_ID, versionId);
        s3Parameter.getResponse().addHeader(GWConstants.X_AMZ_VERSION_ID, versionId);
    }
    s3Parameter.getResponse().setCharacterEncoding(GWConstants.CHARSET_UTF_8);
    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
    try (Writer writer = s3Parameter.getResponse().getWriter()) {
        s3Parameter.getResponse().setContentType(GWConstants.XML_CONTENT_TYPE);
        final AtomicReference<S3Object> s3Object = new AtomicReference<>();
        final AtomicReference<Exception> S3Excp = new AtomicReference<>();
        S3ObjectOperation objectOperation = new S3ObjectOperation(objMeta, null, s3Parameter, versionId, null);
        ObjectMapper jsonMapper = new ObjectMapper();
        S3Metadata s3Metadata = jsonMapper.readValue(meta, S3Metadata.class);
        SortedMap<Integer, Part> constListPart = listPart;
        Thread thread = new Thread() {

            @Override
            public void run() {
                try {
                    s3Object.set(objectOperation.completeMultipart(constListPart));
                } catch (Exception e) {
                    S3Excp.set(e);
                }
            }
        };
        thread.start();
        XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(writer);
        xmlStreamWriter.writeStartDocument();
        xmlStreamWriter.writeStartElement(GWConstants.COMPLETE_MULTIPART_UPLOAD_RESULT);
        xmlStreamWriter.writeDefaultNamespace(GWConstants.AWS_XMLNS);
        while (thread.isAlive()) {
            try {
                thread.join(500);
            } catch (InterruptedException ie) {
                PrintStack.logging(logger, ie);
                throw new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
            }
            xmlStreamWriter.writeCharacters(GWConstants.NEWLINE);
        }
        if (S3Excp.get() != null) {
            PrintStack.logging(logger, S3Excp.get());
            logger.error(S3Excp.get().getMessage());
            throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
        }
        writeSimpleElement(xmlStreamWriter, GWConstants.LOCATION, GWConstants.HTTP + bucket + GWConstants.S3_AMAZON_AWS_COM + object);
        writeSimpleElement(xmlStreamWriter, GWConstants.BUCKET, bucket);
        writeSimpleElement(xmlStreamWriter, GWConstants.KEY, object);
        // make ETag
        StringBuilder sb = new StringBuilder();
        for (Iterator<Map.Entry<Integer, Part>> it = listPart.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<Integer, Part> entry = it.next();
            sb.append(entry.getValue().getPartETag());
        }
        String hex = sb.toString();
        byte[] raw = BaseEncoding.base16().decode(hex.toUpperCase());
        Hasher hasher = Hashing.md5().newHasher();
        hasher.putBytes(raw);
        String digest = hasher.hash().toString() + GWConstants.DASH + listPart.size();
        s3Object.get().setEtag(digest);
        logger.debug(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_MD5, s3Object.get().getEtag());
        writeSimpleElement(xmlStreamWriter, GWConstants.ETAG, GWConstants.DOUBLE_QUOTE + s3Object.get().getEtag() + GWConstants.DOUBLE_QUOTE);
        xmlStreamWriter.writeEndElement();
        xmlStreamWriter.flush();
        s3Metadata.setSize(s3Object.get().getFileSize());
        s3Metadata.setContentLength(s3Object.get().getFileSize());
        s3Metadata.setETag(s3Object.get().getEtag());
        s3Metadata.setLastModified(s3Object.get().getLastModified());
        s3Metadata.setTier(GWConstants.AWS_TIER_STANTARD);
        s3Metadata.setDeleteMarker(s3Object.get().getDeleteMarker());
        s3Metadata.setVersionId(s3Object.get().getVersionId());
        String jsonmeta = "";
        try {
            jsonmeta = jsonMapper.writeValueAsString(s3Metadata);
        } catch (JsonProcessingException e) {
            PrintStack.logging(logger, e);
            throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
        }
        int result = 0;
        try {
            remove(bucket, object);
            objMeta.set(s3Object.get().getEtag(), "", jsonmeta, acl, s3Object.get().getFileSize());
            objMeta.setVersionId(versionId, GWConstants.OBJECT_TYPE_FILE, true);
            result = insertObject(bucket, object, objMeta);
        } catch (GWException e) {
            PrintStack.logging(logger, e);
            throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
        }
        if (result != 0) {
            logger.error(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_FAILED, bucket, object);
        }
        logger.debug(GWConstants.LOG_COMPLETE_MULTIPART_UPLOAD_INFO, bucket, object, s3Object.get().getFileSize(), s3Object.get().getEtag(), acl, versionId);
        objMultipart.abortMultipartUpload(uploadId);
    } catch (IOException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    } catch (XMLStreamException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
}

Example 2 with S3Metadata

use of com.pspace.ifs.ksan.gw.identity.S3Metadata in project ksan by infinistor.

the class CopyObject method process.

@Override
public void process() throws GWException {
    logger.info(GWConstants.LOG_COPY_OBJECT_START);
    String bucket = s3Parameter.getBucketName();
    initBucketInfo(bucket);
    String object = s3Parameter.getObjectName();
    S3Bucket s3Bucket = new S3Bucket();
    s3Bucket.setCors(getBucketInfo().getCors());
    s3Bucket.setAccess(getBucketInfo().getAccess());
    s3Parameter.setBucket(s3Bucket);
    GWUtils.checkCors(s3Parameter);
    if (s3Parameter.isPublicAccess() && GWUtils.isIgnorePublicAcls(s3Parameter)) {
        throw new GWException(GWErrorCode.ACCESS_DENIED, s3Parameter);
    }
    checkGrantBucket(s3Parameter.isPublicAccess(), String.valueOf(s3Parameter.getUser().getUserId()), GWConstants.GRANT_WRITE);
    try {
        object = URLDecoder.decode(object, GWConstants.CHARSET_UTF_8);
    } catch (UnsupportedEncodingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    DataCopyObject dataCopyObject = new DataCopyObject(s3Parameter);
    dataCopyObject.extract();
    String cacheControl = dataCopyObject.getCacheControl();
    String contentDisposition = dataCopyObject.getContentDisposition();
    String contentEncoding = dataCopyObject.getContentEncoding();
    String contentLanguage = dataCopyObject.getContentLanguage();
    String contentType = dataCopyObject.getContentType();
    String contentLengthString = dataCopyObject.getContentLength();
    String metadataDirective = dataCopyObject.getMetadataDirective();
    String serversideEncryption = dataCopyObject.getServerSideEncryption();
    String copySource = dataCopyObject.getCopySource();
    String copySourceIfMatch = dataCopyObject.getCopySourceIfMatch();
    String copySourceIfNoneMatch = dataCopyObject.getCopySourceIfNoneMatch();
    String copySourceIfModifiedSince = dataCopyObject.getCopySourceIfModifiedSince();
    String copySourceIfUnmodifiedSince = dataCopyObject.getCopySourceIfUnmodifiedSince();
    String expires = dataCopyObject.getExpires();
    String customerAlgorithm = dataCopyObject.getServerSideEncryptionCustomerAlgorithm();
    String customerKey = dataCopyObject.getServerSideEncryptionCustomerKey();
    String customerKeyMD5 = dataCopyObject.getServerSideEncryptionCustomerKeyMD5();
    String context = dataCopyObject.getServerSideEncryptionContext();
    String bucketKeyEnabled = dataCopyObject.getServerSideEncryptionBucketKeyEnabled();
    String copySourceCustomerAlgorithm = dataCopyObject.getCopySourceServerSideEncryptionCustomerAlgorithm();
    String copySourceCustomerKey = dataCopyObject.getCopySourceServerSideEncryptionCustomerKey();
    String copySourceCustomerKeyMD5 = dataCopyObject.getCopySourceServerSideEncryptionCustomerKeyMD5();
    Map<String, String> userMetadata = dataCopyObject.getUserMetadata();
    // Check copy source
    if (Strings.isNullOrEmpty(copySource)) {
        logger.error(GWConstants.LOG_COPY_SOURCE_IS_NULL);
        throw new GWException(GWErrorCode.BAD_REQUEST, s3Parameter);
    }
    try {
        copySource = URLDecoder.decode(copySource, GWConstants.CHARSET_UTF_8);
    } catch (UnsupportedEncodingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    if (copySource.startsWith(GWConstants.SLASH)) {
        copySource = copySource.substring(1);
    } else if (copySource.contains(GWConstants.S3_ARN)) {
        logger.error(GWConstants.LOG_COPY_SOURCE_IS_NOT_IMPLEMENTED, copySource);
        throw new GWException(GWErrorCode.NOT_IMPLEMENTED, s3Parameter);
    }
    String[] sourcePath = copySource.split(GWConstants.SLASH, 2);
    if (sourcePath.length != 2) {
        throw new GWException(GWErrorCode.INVALID_ARGUMENT, s3Parameter);
    }
    String srcBucket = sourcePath[0];
    String srcObjectName = sourcePath[1];
    String srcVersionId = null;
    setSrcBucket(srcBucket);
    if (srcObjectName.contains(GWConstants.SUB_PARAMETER_VERSIONID) == true) {
        String[] source = sourcePath[1].split(GWConstants.PARAMETER_BACKSLASH_VERSIONID, 2);
        srcObjectName = source[0];
        srcVersionId = source[1].replaceAll(GWConstants.DOUBLE_QUOTE, "");
    }
    s3Parameter.setSrcBucketName(srcBucket);
    s3Parameter.setSrcVersionId(srcVersionId);
    s3Parameter.setSrcPath(srcObjectName);
    logger.debug(GWConstants.LOG_SOURCE_INFO, srcBucket, srcObjectName, srcVersionId);
    String versioningStatus = getBucketVersioning(srcBucket);
    Metadata srcMeta = null;
    if (GWConstants.VERSIONING_ENABLED.equalsIgnoreCase(versioningStatus)) {
        if (!Strings.isNullOrEmpty(srcVersionId) && !GWConstants.VERSIONING_DISABLE_TAIL.equals(srcVersionId)) {
            srcMeta = open(srcBucket, srcObjectName, srcVersionId);
        } else {
            srcMeta = open(srcBucket, srcObjectName);
        }
    } else {
        srcMeta = open(srcBucket, srcObjectName);
    }
    srcVersionId = srcMeta.getVersionId();
    srcMeta.setAcl(GWUtils.makeOriginalXml(srcMeta.getAcl(), s3Parameter));
    checkGrantObject(s3Parameter.isPublicAccess(), srcMeta, String.valueOf(s3Parameter.getUser().getUserId()), GWConstants.GRANT_READ);
    // get metadata
    S3Metadata s3Metadata = null;
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        s3Metadata = objectMapper.readValue(srcMeta.getMeta(), S3Metadata.class);
    } catch (JsonProcessingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.INTERNAL_SERVER_ERROR, s3Parameter);
    }
    // Check match
    if (!Strings.isNullOrEmpty(copySourceIfMatch)) {
        logger.debug(GWConstants.LOG_SOURCE_ETAG_MATCH, s3Metadata.getETag(), copySourceIfMatch.replace(GWConstants.DOUBLE_QUOTE, ""));
        if (!GWUtils.maybeQuoteETag(s3Metadata.getETag()).equals(copySourceIfMatch.replace(GWConstants.DOUBLE_QUOTE, ""))) {
            throw new GWException(GWErrorCode.PRECONDITION_FAILED, s3Parameter);
        }
    }
    if (!Strings.isNullOrEmpty(copySourceIfNoneMatch)) {
        logger.debug(GWConstants.LOG_SOURCE_ETAG_MATCH, s3Metadata.getETag(), copySourceIfNoneMatch.replace(GWConstants.DOUBLE_QUOTE, ""));
        if (GWUtils.maybeQuoteETag(s3Metadata.getETag()).equals(copySourceIfNoneMatch.replace(GWConstants.DOUBLE_QUOTE, ""))) {
            throw new GWException(GWErrorCode.DOES_NOT_MATCH, String.format(GWConstants.LOG_ETAG_IS_MISMATCH), s3Parameter);
        }
    }
    if (!Strings.isNullOrEmpty(copySourceIfModifiedSince)) {
        long copySourceIfModifiedSinceLong = Long.parseLong(copySourceIfModifiedSince);
        if (copySourceIfModifiedSinceLong != -1) {
            Date modifiedSince = new Date(copySourceIfModifiedSinceLong);
            if (s3Metadata.getLastModified().before(modifiedSince)) {
                throw new GWException(GWErrorCode.DOES_NOT_MATCH, String.format(GWConstants.LOG_MATCH_BEFORE, s3Metadata.getLastModified(), modifiedSince), s3Parameter);
            }
        }
    }
    if (!Strings.isNullOrEmpty(copySourceIfUnmodifiedSince)) {
        long copySourceIfUnmodifiedSinceLong = Long.parseLong(copySourceIfUnmodifiedSince);
        if (copySourceIfUnmodifiedSinceLong != -1) {
            Date unmodifiedSince = new Date(copySourceIfUnmodifiedSinceLong);
            if (s3Metadata.getLastModified().after(unmodifiedSince)) {
                throw new GWException(GWErrorCode.PRECONDITION_FAILED, String.format(GWConstants.LOG_MATCH_AFTER, s3Metadata.getLastModified(), unmodifiedSince), s3Parameter);
            }
        }
    }
    accessControlPolicy = new AccessControlPolicy();
    accessControlPolicy.aclList = new AccessControlList();
    accessControlPolicy.aclList.grants = new ArrayList<Grant>();
    accessControlPolicy.owner = new Owner();
    accessControlPolicy.owner.id = String.valueOf(s3Parameter.getUser().getUserId());
    accessControlPolicy.owner.displayName = s3Parameter.getUser().getUserName();
    String aclXml = GWUtils.makeAclXml(accessControlPolicy, null, dataCopyObject.hasAclKeyword(), null, dataCopyObject.getAcl(), getBucketInfo(), String.valueOf(s3Parameter.getUser().getUserId()), s3Parameter.getUser().getUserName(), dataCopyObject.getGrantRead(), dataCopyObject.getGrantWrite(), dataCopyObject.getGrantFullControl(), dataCopyObject.getGrantReadAcp(), dataCopyObject.getGrantWriteAcp(), s3Parameter);
    boolean bReplaceMetadata = false;
    logger.debug(GWConstants.LOG_COPY_OBJECT_METADATA_DIRECTIVE, metadataDirective);
    if (!Strings.isNullOrEmpty(metadataDirective) && metadataDirective.equalsIgnoreCase(GWConstants.REPLACE)) {
        bReplaceMetadata = true;
    }
    s3Metadata.setOwnerId(String.valueOf(s3Parameter.getUser().getUserId()));
    s3Metadata.setOwnerName(s3Parameter.getUser().getUserName());
    if (userMetadata.size() > 0) {
        for (String key : userMetadata.keySet()) {
            logger.info(GWConstants.LOG_COPY_OBJECT_USER_METADATA, key, userMetadata.get(key));
        }
        if (bReplaceMetadata) {
            logger.info(GWConstants.LOG_COPY_OBJECT_REPLACE_USER_METADATA, userMetadata.toString());
            s3Metadata.setUserMetadataMap(userMetadata);
        }
    }
    if (!Strings.isNullOrEmpty(cacheControl) && bReplaceMetadata) {
        s3Metadata.setCacheControl(cacheControl);
    }
    if (!Strings.isNullOrEmpty(contentDisposition) && bReplaceMetadata) {
        s3Metadata.setContentDisposition(contentDisposition);
    }
    if (!Strings.isNullOrEmpty(contentEncoding) && bReplaceMetadata) {
        s3Metadata.setContentEncoding(contentEncoding);
    }
    if (!Strings.isNullOrEmpty(contentLanguage) && bReplaceMetadata) {
        s3Metadata.setContentLanguage(contentLanguage);
    }
    if (!Strings.isNullOrEmpty(contentType) && bReplaceMetadata) {
        s3Metadata.setContentType(contentType);
    }
    if (Strings.isNullOrEmpty(contentLengthString)) {
        logger.error(GWErrorCode.MISSING_CONTENT_LENGTH.getMessage());
        throw new GWException(GWErrorCode.MISSING_CONTENT_LENGTH, s3Parameter);
    }
    /*else {
            try {
                long contentLength = Long.parseLong(contentLengthString);
                s3Metadata.setContentLength(contentLength);
            } catch (NumberFormatException e) {
                logger.error(e.getMessage());
				throw new S3Exception(S3ErrorCode.INVALID_ARGUMENT, e);
            }
        }*/
    String jsonmeta = "";
    // update
    if (s3Parameter.getSrcBucketName().equals(bucket) && s3Parameter.getSrcPath().equals(object)) {
        if (!Strings.isNullOrEmpty(metadataDirective) && bReplaceMetadata) {
            // update metadata
            try {
                S3Metadata metaClass = objectMapper.readValue(srcMeta.getMeta(), S3Metadata.class);
                s3Metadata.setTier(GWConstants.AWS_TIER_STANTARD);
                s3Metadata.setContentLength(metaClass.getContentLength());
                s3Metadata.setETag(metaClass.getETag());
            } catch (JsonProcessingException e) {
                PrintStack.logging(logger, e);
                throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
            }
            s3Metadata.setLastModified(new Date());
            try {
                jsonmeta = objectMapper.writeValueAsString(s3Metadata);
            } catch (JsonProcessingException e) {
                PrintStack.logging(logger, e);
                throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
            }
            logger.debug(GWConstants.LOG_COPY_OBJECT_META, jsonmeta);
            srcMeta.setMeta(jsonmeta);
            updateObjectMeta(srcMeta);
            s3Parameter.getResponse().setCharacterEncoding(GWConstants.CHARSET_UTF_8);
            XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
            try (Writer writer = s3Parameter.getResponse().getWriter()) {
                s3Parameter.getResponse().setContentType(GWConstants.XML_CONTENT_TYPE);
                XMLStreamWriter xmlout = xmlOutputFactory.createXMLStreamWriter(writer);
                xmlout.writeStartDocument();
                xmlout.writeStartElement(GWConstants.COPY_OBJECT_RESULT);
                xmlout.writeDefaultNamespace(GWConstants.AWS_XMLNS);
                writeSimpleElement(xmlout, GWConstants.LAST_MODIFIED, formatDate(s3Metadata.getLastModified()));
                writeSimpleElement(xmlout, GWConstants.ETAG, GWUtils.maybeQuoteETag(s3Metadata.getETag()));
                xmlout.writeEndElement();
                xmlout.flush();
            } catch (XMLStreamException | IOException e) {
                PrintStack.logging(logger, e);
                throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
            }
            s3Parameter.getResponse().setStatus(HttpServletResponse.SC_OK);
            return;
        } else {
            logger.error(GWErrorCode.INVALID_REQUEST.getMessage());
            throw new GWException(GWErrorCode.INVALID_REQUEST, s3Parameter);
        }
    }
    Metadata objMeta = createCopy(srcBucket, srcObjectName, srcVersionId, bucket, object);
    versioningStatus = getBucketVersioning(bucket);
    String versionId = null;
    if (GWConstants.VERSIONING_ENABLED.equalsIgnoreCase(versioningStatus)) {
        versionId = String.valueOf(System.nanoTime());
    } else {
        versionId = GWConstants.VERSIONING_DISABLE_TAIL;
    }
    S3ObjectOperation objectOperation = new S3ObjectOperation(objMeta, s3Metadata, s3Parameter, versionId, null);
    S3Object s3Object = objectOperation.copyObject(srcMeta);
    s3Metadata.setETag(s3Object.getEtag());
    s3Metadata.setSize(s3Object.getFileSize());
    s3Metadata.setTier(GWConstants.AWS_TIER_STANTARD);
    s3Metadata.setLastModified(s3Object.getLastModified());
    s3Metadata.setDeleteMarker(s3Object.getDeleteMarker());
    s3Metadata.setVersionId(s3Object.getVersionId());
    try {
        jsonmeta = objectMapper.writeValueAsString(s3Metadata);
    } catch (JsonProcessingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    logger.debug(GWConstants.LOG_COPY_OBJECT_META, jsonmeta);
    try {
        int result;
        objMeta.set(s3Object.getEtag(), srcMeta.getTag(), jsonmeta, aclXml, s3Object.getFileSize());
        objMeta.setVersionId(versionId, GWConstants.OBJECT_TYPE_FILE, true);
        result = insertObject(bucket, object, objMeta);
        if (result != 0) {
            logger.error(GWConstants.LOG_COPY_OBJECT_FAILED, bucket, object);
        }
        logger.debug(GWConstants.LOG_COPY_OBJECT_INFO, bucket, object, s3Object.getFileSize(), s3Object.getEtag(), srcMeta.getAcl(), srcMeta.getAcl(), versionId);
    } catch (GWException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    s3Parameter.getResponse().setCharacterEncoding(GWConstants.CHARSET_UTF_8);
    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
    try (Writer writer = s3Parameter.getResponse().getWriter()) {
        s3Parameter.getResponse().setContentType(GWConstants.XML_CONTENT_TYPE);
        XMLStreamWriter xmlout = xmlOutputFactory.createXMLStreamWriter(writer);
        xmlout.writeStartDocument();
        xmlout.writeStartElement(GWConstants.COPY_OBJECT_RESULT);
        xmlout.writeDefaultNamespace(GWConstants.AWS_XMLNS);
        writeSimpleElement(xmlout, GWConstants.LAST_MODIFIED, formatDate(s3Metadata.getLastModified()));
        writeSimpleElement(xmlout, GWConstants.ETAG, GWUtils.maybeQuoteETag(s3Object.getEtag()));
        xmlout.writeEndElement();
        xmlout.flush();
    } catch (XMLStreamException | IOException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    s3Parameter.getResponse().setStatus(HttpServletResponse.SC_OK);
}

Example 3 with S3Metadata

use of com.pspace.ifs.ksan.gw.identity.S3Metadata in project ksan by infinistor.

the class GetObject method process.

@Override
public void process() throws GWException {
    logger.info(GWConstants.LOG_GET_OBJECT_START);
    String bucket = s3Parameter.getBucketName();
    initBucketInfo(bucket);
    String object = s3Parameter.getObjectName();
    logger.debug(GWConstants.LOG_BUCKET_OBJECT, bucket, object);
    S3Bucket s3Bucket = new S3Bucket();
    s3Bucket.setCors(getBucketInfo().getCors());
    s3Bucket.setAccess(getBucketInfo().getAccess());
    s3Parameter.setBucket(s3Bucket);
    GWUtils.checkCors(s3Parameter);
    if (s3Parameter.isPublicAccess() && GWUtils.isIgnorePublicAcls(s3Parameter)) {
        throw new GWException(GWErrorCode.ACCESS_DENIED, s3Parameter);
    }
    DataGetObject dataGetObject = new DataGetObject(s3Parameter);
    dataGetObject.extract();
    String versionId = dataGetObject.getVersionId();
    String range = dataGetObject.getRange();
    String ifMatch = dataGetObject.getIfMatch();
    String ifNoneMatch = dataGetObject.getIfNoneMatch();
    String ifModifiedSince = dataGetObject.getIfModifiedSince();
    String ifUnmodifiedSince = dataGetObject.getIfUnmodifiedSince();
    String versioningStatus = getBucketVersioning(bucket);
    Metadata objMeta = null;
    if (Strings.isNullOrEmpty(versionId)) {
        objMeta = open(bucket, object);
        versionId = objMeta.getVersionId();
    } else {
        objMeta = open(bucket, object, versionId);
    }
    logger.debug(GWConstants.LOG_OBJECT_META, objMeta.toString());
    objMeta.setAcl(GWUtils.makeOriginalXml(objMeta.getAcl(), s3Parameter));
    checkGrantObject(s3Parameter.isPublicAccess(), objMeta, String.valueOf(s3Parameter.getUser().getUserId()), GWConstants.GRANT_READ);
    S3Metadata s3Metadata = null;
    // meta info
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        logger.debug(GWConstants.LOG_META, objMeta.getMeta());
        s3Metadata = objectMapper.readValue(objMeta.getMeta(), S3Metadata.class);
    } catch (JsonProcessingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    // check customer-key
    if (!Strings.isNullOrEmpty(s3Metadata.getCustomerKey())) {
        if (!Strings.isNullOrEmpty(dataGetObject.getServerSideEncryptionCustomerKey())) {
            if (!s3Metadata.getCustomerKey().equals(dataGetObject.getServerSideEncryptionCustomerKey())) {
                logger.warn(GWConstants.LOG_GET_OBJECT_CUSTOMER_KEY_NO_MATCH);
                throw new GWException(GWErrorCode.KEY_DOES_NOT_MATCH, s3Parameter);
            }
        } else {
            logger.warn(GWConstants.ENCRYPTION_CUSTOMER_KEY_IS_NULL);
            throw new GWException(GWErrorCode.BAD_REQUEST, s3Parameter);
        }
    }
    // Check match
    if (!Strings.isNullOrEmpty(ifMatch)) {
        logger.debug(GWConstants.LOG_GET_OBJECT_IF_MATCH_ETAG, s3Metadata.getETag(), ifMatch.replace(GWConstants.DOUBLE_QUOTE, ""));
        if (!s3Metadata.getETag().equals(ifMatch.replace(GWConstants.DOUBLE_QUOTE, ""))) {
            logger.error(GWConstants.LOG_GET_OBJECT_ETAG_DIFFERENT);
            throw new GWException(GWErrorCode.PRECONDITION_FAILED, s3Parameter);
        }
    }
    if (!Strings.isNullOrEmpty(ifNoneMatch)) {
        logger.debug(GWConstants.LOG_GET_OBJECT_IF_NONE_MATCH_ETAG, s3Metadata.getETag(), ifNoneMatch.replace(GWConstants.DOUBLE_QUOTE, ""));
        if (s3Metadata.getETag().equals(ifNoneMatch.replace(GWConstants.DOUBLE_QUOTE, ""))) {
            logger.error(GWConstants.LOG_GET_OBJECT_ETAG_SAME);
            throw new GWException(GWErrorCode.DOES_NOT_MATCH, String.format(GWConstants.LOG_ETAG_IS_MISMATCH), s3Parameter);
        }
    }
    if (!Strings.isNullOrEmpty(ifModifiedSince)) {
        Date modifiedSince = new Date(ifModifiedSince);
        if (s3Metadata.getLastModified().before(modifiedSince)) {
            throw new GWException(GWErrorCode.DOES_NOT_MATCH, String.format(GWConstants.LOG_MATCH_BEFORE, s3Metadata.getLastModified(), modifiedSince), s3Parameter);
        }
    }
    if (!Strings.isNullOrEmpty(ifUnmodifiedSince)) {
        Date unmodifiedSince = new Date(ifUnmodifiedSince);
        if (s3Metadata.getLastModified().after(unmodifiedSince)) {
            throw new GWException(GWErrorCode.PRECONDITION_FAILED, String.format(GWConstants.LOG_MATCH_AFTER, s3Metadata.getLastModified(), unmodifiedSince), s3Parameter);
        }
    }
    ResultRange resultRange = new ResultRange(range, s3Metadata, s3Parameter);
    addMetadataToResponse(s3Parameter.getResponse(), s3Metadata, resultRange.getContentLengthHeaders(), resultRange.getStreamSize());
    S3ObjectOperation objectOperation = new S3ObjectOperation(objMeta, s3Metadata, s3Parameter, versionId, null);
    try {
        objectOperation.getObject(resultRange.getS3Range());
    } catch (Exception e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    s3Parameter.getResponse().setStatus(resultRange.getStatus());
}

Example 4 with S3Metadata

use of com.pspace.ifs.ksan.gw.identity.S3Metadata in project ksan by infinistor.

the class GetObjectRetention method process.

@Override
public void process() throws GWException {
    logger.info(GWConstants.LOG_GET_OBJECT_RETENTION_START);
    String bucket = s3Parameter.getBucketName();
    initBucketInfo(bucket);
    String object = s3Parameter.getObjectName();
    logger.debug(GWConstants.LOG_BUCKET_OBJECT, bucket, object);
    S3Bucket s3Bucket = new S3Bucket();
    s3Bucket.setCors(getBucketInfo().getCors());
    s3Bucket.setAccess(getBucketInfo().getAccess());
    s3Parameter.setBucket(s3Bucket);
    GWUtils.checkCors(s3Parameter);
    if (s3Parameter.isPublicAccess() && GWUtils.isIgnorePublicAcls(s3Parameter)) {
        throw new GWException(GWErrorCode.ACCESS_DENIED, s3Parameter);
    }
    DataGetObjectRetention dataGetObjectRetention = new DataGetObjectRetention(s3Parameter);
    dataGetObjectRetention.extract();
    String versionId = dataGetObjectRetention.getVersionId();
    Metadata objMeta = null;
    if (Strings.isNullOrEmpty(versionId)) {
        objMeta = open(bucket, object);
    } else {
        objMeta = open(bucket, object, versionId);
    }
    logger.debug(GWConstants.LOG_OBJECT_META, objMeta.toString());
    objMeta.setAcl(GWUtils.makeOriginalXml(objMeta.getAcl(), s3Parameter));
    checkGrantObjectOwner(s3Parameter.isPublicAccess(), objMeta, String.valueOf(s3Parameter.getUser().getUserId()), GWConstants.GRANT_READ);
    String meta = objMeta.getMeta();
    S3Metadata s3Metadata;
    try {
        s3Metadata = new ObjectMapper().readValue(meta, S3Metadata.class);
    } catch (JsonProcessingException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
    if (!Strings.isNullOrEmpty(s3Metadata.getLockMode())) {
        XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newFactory();
        javax.xml.stream.XMLStreamWriter xml;
        try {
            xml = xmlOutputFactory.createXMLStreamWriter(s3Parameter.getResponse().getOutputStream());
            xml.writeStartDocument();
            xml.writeStartElement(GWConstants.RETENTION);
            writeSimpleElement(xml, GWConstants.XML_MODE, s3Metadata.getLockMode());
            writeSimpleElement(xml, GWConstants.RETAIN_UNTIL_DATE, s3Metadata.getLockExpires());
            xml.writeEndElement();
            xml.flush();
        } catch (XMLStreamException | IOException e) {
            PrintStack.logging(logger, e);
            throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
        }
    } else {
        throw new GWException(GWErrorCode.INVALID_REQUEST, s3Parameter);
    }
    s3Parameter.getResponse().setStatus(HttpServletResponse.SC_OK);
}

Example 5 with S3Metadata

use of com.pspace.ifs.ksan.gw.identity.S3Metadata in project ksan by infinistor.

the class ListObjectVersions method process.

@Override
public void process() throws GWException {
    logger.info(GWConstants.LOG_LIST_OBJECT_VERSIONS_START);
    String bucket = s3Parameter.getBucketName();
    initBucketInfo(bucket);
    S3Bucket s3Bucket = new S3Bucket();
    s3Bucket.setCors(getBucketInfo().getCors());
    s3Bucket.setAccess(getBucketInfo().getAccess());
    s3Parameter.setBucket(s3Bucket);
    GWUtils.checkCors(s3Parameter);
    if (s3Parameter.isPublicAccess() && GWUtils.isIgnorePublicAcls(s3Parameter)) {
        throw new GWException(GWErrorCode.ACCESS_DENIED, s3Parameter);
    }
    checkGrantBucket(s3Parameter.isPublicAccess(), String.valueOf(s3Parameter.getUser().getUserId()), GWConstants.GRANT_READ);
    DataListObjectVersions dataListObjectVersions = new DataListObjectVersions(s3Parameter);
    dataListObjectVersions.extract();
    String delimiter = dataListObjectVersions.getDelimiter();
    String encodingType = dataListObjectVersions.getEncodingType();
    String keyMarker = dataListObjectVersions.getKeyMarker();
    String maxKeys = dataListObjectVersions.getMaxKeys();
    String prefix = dataListObjectVersions.getPrefix();
    String versionIdMarker = dataListObjectVersions.getVersionIdMarker();
    S3ObjectList s3ObjectList = new S3ObjectList();
    s3ObjectList.setDelimiter(delimiter);
    s3ObjectList.setEncodingType(encodingType);
    s3ObjectList.setKeyMarker(keyMarker);
    s3ObjectList.setMaxKeys(maxKeys);
    if (Strings.isNullOrEmpty(s3ObjectList.getMaxKeys())) {
        s3ObjectList.setMaxKeys(GWConstants.DEFAULT_MAX_KEYS);
    }
    logger.debug(GWConstants.LOG_LIST_OBJECT_VERSIONS_MAXKEYS, s3ObjectList.getMaxKeys());
    if (Integer.valueOf(s3ObjectList.getMaxKeys()) < 0) {
        throw new GWException(GWErrorCode.INVALID_ARGUMENT, s3Parameter);
    }
    s3ObjectList.setPrefix(prefix);
    s3ObjectList.setVersionIdMarker(versionIdMarker);
    s3Parameter.getResponse().setCharacterEncoding(GWConstants.CHARSET_UTF_8);
    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
    ObjectListParameter objectListParameter = listObjectVersions(bucket, s3ObjectList);
    try (Writer writer = s3Parameter.getResponse().getWriter()) {
        s3Parameter.getResponse().setContentType(GWConstants.XML_CONTENT_TYPE);
        XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(writer);
        xmlStreamWriter.writeStartDocument();
        xmlStreamWriter.writeStartElement(GWConstants.LIST_VERSIONS_RESULT);
        xmlStreamWriter.writeDefaultNamespace(GWConstants.AWS_XMLNS);
        writeSimpleElement(xmlStreamWriter, GWConstants.XML_NAME, bucket);
        if (prefix == null) {
            xmlStreamWriter.writeEmptyElement(GWConstants.XML_PREFIX);
        } else {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_PREFIX, GWUtils.encodeBlob(encodingType, prefix));
        }
        writeSimpleElement(xmlStreamWriter, GWConstants.XML_MAX_KEYS, String.valueOf(s3ObjectList.getMaxKeys()));
        if (keyMarker == null) {
            xmlStreamWriter.writeEmptyElement(GWConstants.XML_KEY_MARKER);
        } else {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_KEY_MARKER, GWUtils.encodeBlob(encodingType, keyMarker));
        }
        if (versionIdMarker == null) {
            xmlStreamWriter.writeEmptyElement(GWConstants.XML_VERSIONID_MARKER);
        } else {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_VERSIONID_MARKER, GWUtils.encodeBlob(encodingType, versionIdMarker));
        }
        logger.debug(GWConstants.LOG_LIST_OBJECT_VERSIONS_PARAMETER_INFO, objectListParameter, objectListParameter.getObjects());
        writeSimpleElement(xmlStreamWriter, GWConstants.XML_KEY_COUNT, String.valueOf(objectListParameter.getObjects().size()));
        if (delimiter != null) {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_DELIMITER, GWUtils.encodeBlob(encodingType, delimiter));
        }
        if (encodingType != null && encodingType.equals(GWConstants.URL)) {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_ENCODING_TYPE, encodingType);
        }
        if (objectListParameter.isTruncated()) {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_IS_TRUNCATED, GWConstants.XML_TRUE);
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_NEXT_KEY_MARKER, GWUtils.encodeBlob(encodingType, objectListParameter.getNextMarker()));
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_NEXT_VERSIONID_MARKER, GWUtils.encodeBlob(encodingType, objectListParameter.getNextVersion()));
        } else {
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_IS_TRUNCATED, GWConstants.XML_FALSE);
        }
        for (S3Metadata s3Metadata : objectListParameter.getObjects()) {
            if (s3Metadata != null) {
                if (s3Metadata.getDeleteMarker() != null) {
                    if (s3Metadata.getDeleteMarker().compareTo(GWConstants.OBJECT_TYPE_MARK) == 0) {
                        xmlStreamWriter.writeStartElement(GWConstants.XML_DELETE_MARKER);
                    } else {
                        xmlStreamWriter.writeStartElement(GWConstants.VERSION);
                    }
                    writeSimpleElement(xmlStreamWriter, GWConstants.KEY, GWUtils.encodeBlob(encodingType, s3Metadata.getName()));
                    if (s3Metadata.getLastModified() != null) {
                        writeSimpleElement(xmlStreamWriter, GWConstants.LAST_MODIFIED, formatDate(s3Metadata.getLastModified()));
                    }
                    if (s3Metadata.getETag() != null) {
                        writeSimpleElement(xmlStreamWriter, GWConstants.ETAG, GWUtils.maybeQuoteETag(s3Metadata.getETag()));
                    }
                    writeSimpleElement(xmlStreamWriter, GWConstants.XML_SIZE, s3Metadata.getSize().toString());
                    writeSimpleElement(xmlStreamWriter, GWConstants.STORAGE_CLASS, s3Metadata.getTier());
                    writeSimpleElement(xmlStreamWriter, GWConstants.VERSIONID, s3Metadata.getVersionId());
                    writeSimpleElement(xmlStreamWriter, GWConstants.XML_IS_LATEST, s3Metadata.getIsLatest());
                    writeOwnerInfini(xmlStreamWriter, s3Metadata.getOwnerId(), s3Metadata.getOwnerName());
                    xmlStreamWriter.writeEndElement();
                    logger.debug(GWConstants.LOG_LIST_OBJECT_VERSIONS_INFO, s3Metadata.getName(), s3Metadata.getVersionId());
                }
            }
        }
        for (Entry<String, String> entry : objectListParameter.getCommonPrefixes().entrySet()) {
            xmlStreamWriter.writeStartElement(GWConstants.XML_COMMON_PREFIXES);
            writeSimpleElement(xmlStreamWriter, GWConstants.XML_PREFIX, GWUtils.encodeBlob(encodingType, entry.getValue()));
            xmlStreamWriter.writeEndElement();
        }
        xmlStreamWriter.writeEndElement();
        xmlStreamWriter.flush();
    } catch (IOException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    } catch (XMLStreamException e) {
        PrintStack.logging(logger, e);
        throw new GWException(GWErrorCode.SERVER_ERROR, s3Parameter);
    }
}