Package org.jets3t.service.model

Examples of org.jets3t.service.model.StorageObject


            public void fireCancelEvent() {
                List cancelledObjectsList = new ArrayList();
                Iterator iter = pendingObjectKeysList.iterator();
                while (iter.hasNext()) {
                    String key = (String) iter.next();
                    cancelledObjectsList.add(new StorageObject(key));
                }
                StorageObject[] cancelledObjects = (StorageObject[]) cancelledObjectsList
                    .toArray(new StorageObject[cancelledObjectsList.size()]);
                success[0] = false;
                fireServiceEvent(GetObjectHeadsEvent.newCancelledEvent(cancelledObjects, uniqueOperationId));
View Full Code Here


        }

        Map<String, Object> map = new HashMap<String, Object>();
        map.putAll(convertHeadersToMap(httpResponse.getAllHeaders()));

        StorageObject responseObject = newObject();
        responseObject.setKey(objectKey);
        if(!headOnly) {
            responseObject.setContentLength(httpResponse.getEntity().getContentLength());
        }
        responseObject.setBucketName(bucketName);
        responseObject.replaceAllMetadata(ServiceUtils.cleanRestMetadataMap(
                map, this.getRestHeaderPrefix(), this.getRestMetadataPrefix()));
        responseObject.setMetadataComplete(true); // Flag this object as having the complete metadata set.
        if(!headOnly) {
            HttpMethodReleaseInputStream releaseIS = new HttpMethodReleaseInputStream(httpResponse);
            responseObject.setDataInputStream(releaseIS);
        }
        else {
            // Release connection after HEAD (there's no response content)
            if(log.isDebugEnabled()) {
                log.debug("Releasing HttpMethod after HEAD");
View Full Code Here

                log.warn("Unable to close data input stream for object '" + object.getKey() + "'", e);
            }
        }

        try {
            StorageObject uploadedObject = ServiceUtils.buildObjectFromUrl(
                    putMethod.getURI().getHost(),
                    putMethod.getURI().getRawPath(),
                    s3Endpoint);
            uploadedObject.setBucketName(uploadedObject.getBucketName());

            // Add all metadata returned by S3 to uploaded object.
            Map<String, Object> map = new HashMap<String, Object>();
            map.putAll(convertHeadersToMap(httpResponse.getAllHeaders()));
            uploadedObject.replaceAllMetadata(ServiceUtils.cleanRestMetadataMap(
                    map, this.getRestHeaderPrefix(), this.getRestMetadataPrefix()));

            // Confirm that the data was not corrupted in transit by checking S3's calculated
            // hash value with the locally computed value. This is only necessary if the user
            // did not provide a Content-MD5 header with the original object.
View Full Code Here

                    // Invoke lazy upload object creator.
                    int maxBatchSize = Math.min(uploadBatchSize, objectsToUpload.size());
                    for (int i = 0; i < maxBatchSize; i++) {
                        LazyPreparedUploadObject lazyObj = objectsToUpload.remove(0);
                        StorageObject object = null;

                        try {
                            object = lazyObj.prepareUploadObject();
                        } catch (FileNotFoundException e) {
                            if (skipMissingFiles) {
                                printOutputLine(
                                    "WARNING: Skipping unreadable file: "
                                    + lazyObj.getFile().getAbsolutePath(),
                                    REPORT_LEVEL_NONE);
                                continue;
                            } else {
                                throw e;
                            }
                        }

                        if (multipartUtils != null
                            && multipartUtils.isFileLargerThanMaxPartSize(lazyObj.getFile()))
                        {
                            objectsForMultipartUpload.add(object);
                        } else {
                            objectsForStandardPut.add(object);
                        }
                    }

                    // Perform standard object uploads
                    if (objectsForStandardPut.size() > 0) {
                        (new ThreadedStorageService(storageService, serviceEventAdaptor)).putObjects(
                            bucket.getName(), objectsForStandardPut.toArray(new StorageObject[] {}));
                        serviceEventAdaptor.throwErrorIfPresent();
                    }

                    // Perform multipart uploads
                    if (objectsForMultipartUpload.size() > 0) {
                        multipartUtils.uploadObjects(
                            bucket.getName(), (S3Service)storageService,
                            objectsForMultipartUpload, serviceEventAdaptor);
                    }
                }
            } while (objectKeyIter.hasNext()); // End of upload loop

        } while (priorLastKey != null); // End of list and upload loop

        // Delete objects that don't correspond with local files.
        List<StorageObject> objectsToDelete = new ArrayList<StorageObject>();
        Iterator<String> serverOnlyIter = mergedDiscrepancyResults.onlyOnServerKeys.iterator();
        while (serverOnlyIter.hasNext()) {
            // Relative key
            String relativeKeyPath = serverOnlyIter.next();

            // Build absolute key path for object.
            String targetKey = relativeKeyPath;
            if (rootObjectPath.length() > 0) {
                if (rootObjectPath.endsWith(Constants.FILE_PATH_DELIM)) {
                    targetKey = rootObjectPath + targetKey;
                } else {
                    targetKey = rootObjectPath + Constants.FILE_PATH_DELIM + targetKey;
                }
            }
            StorageObject object = new StorageObject(targetKey);

            if (isKeepFiles || isNoDelete) {
                printOutputLine("d " + relativeKeyPath, REPORT_LEVEL_DIFFERENCES);
            } else {
                printOutputLine("D " + relativeKeyPath, REPORT_LEVEL_ACTIONS);
View Full Code Here

            // Optionally download objects in batches to minimize memory use
            do {
                List<DownloadPackage> downloadPackagesList = new ArrayList<DownloadPackage>();
                while (objectKeyIter.hasNext()) {
                    String keyPath = objectKeyIter.next();
                    StorageObject object = objectsMap.get(keyPath);
                    String localPath = keyPath;

                    // If object metadata is not available, skip zero-byte objects that
                    // are not definitively directory place-holders, since we can't tell
                    // whether they are directory place-holders or normal empty files.
                    if (!object.isMetadataComplete()
                        && object.getContentLength() == 0
                        && !object.isDirectoryPlaceholder())
                    {
                        continue;
                    }

                    File fileTarget = new File(localDirectory, keyPath);
                    // Create local directories corresponding to objects flagged as dirs.
                    if (object.isDirectoryPlaceholder()) {
                        localPath = ObjectUtils.convertDirPlaceholderKeyNameToDirName(keyPath);
                        fileTarget = new File(localDirectory, localPath);
                        if (doAction) {
                            fileTarget.mkdirs();
                        }
View Full Code Here

            this.aclString = aclString;
            this.encryptionUtil = encryptionUtil;
        }

        public StorageObject prepareUploadObject() throws Exception {
            StorageObject newObject = ObjectUtils.createObjectForUpload(
                targetKey, file, md5HashOfFile, encryptionUtil, isGzipEnabled, null);

            if ("PUBLIC_READ".equalsIgnoreCase(aclString)) {
                newObject.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
            } else if ("PUBLIC_READ_WRITE".equalsIgnoreCase(aclString)) {
                newObject.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ_WRITE);
            } else if ("PRIVATE".equalsIgnoreCase(aclString)) {
                // Private is the default, no need to add an ACL
            } else {
                throw new Exception("Invalid value for ACL string: " + aclString);
            }

            // Apply custom metadata items to upload object.
            newObject.addAllMetadata(customMetadata);

            return newObject;
        }
View Full Code Here

        assertFalse(ServiceUtils.isEtagAlsoAnMD5Hash(
            "cb8aaa4056eb349af16b1907280dee18cb"));
    }

    public void testMd5ETag() throws Exception {
        StorageObject so = new S3Object("");

        // MD5 ETag values
        so.setETag("cb8aaa4056eb349af16b1907280dee18");
        assertEquals("y4qqQFbrNJrxaxkHKA3uGA==", so.getMd5HashAsBase64());
    }
View Full Code Here

        so.setETag("cb8aaa4056eb349af16b1907280dee18");
        assertEquals("y4qqQFbrNJrxaxkHKA3uGA==", so.getMd5HashAsBase64());
    }

    public void testNonMd5ETag() throws Exception {
        StorageObject so = new S3Object("");

        so.setETag("cb8aaa4056eb349af16b1907280dee18-1");
        assertEquals(null, so.getMd5HashAsBase64());

        so.setETag("cb8aaa4056eb349af16b1907280dee");
        assertEquals(null, so.getMd5HashAsBase64());

        so.setETag("cb8aaa4056eb349af16b1907280dee1");
        assertEquals(null, so.getMd5HashAsBase64());

        so.setETag("cb8aaa4056eb349af16b1907280dee18cb");
        assertEquals(null, so.getMd5HashAsBase64());

        so.setETag("12345");
        String hash = so.getMd5HashAsBase64();
        assertEquals(null, hash);

        so.setETag("123456-7");
        hash = so.getMd5HashAsBase64();
        assertEquals(null, hash);
    }
View Full Code Here

            segFIS.close();
        }
    }

    public void testCaseInsensitiveObjectMetadataNames() {
        StorageObject obj = new StorageObject("SomeName");

        // Get metadata names, case-insensitive
        obj.addMetadata("My-name", "1");
        assertEquals("1", obj.getMetadata("My-name"));
        assertEquals("1", obj.getMetadata("My-Name"));
        assertEquals("1", obj.getMetadata("my-name"));

        assertNull(obj.getMetadata(null));

        // Check for presense of metadata, case-insensitive
        assertTrue(obj.containsMetadata("My-name"));
        assertTrue(obj.containsMetadata("My-Name"));
        assertTrue(obj.containsMetadata("my-name"));

        // New item with same case-insensitive name replaces old value
        obj.addMetadata("My-Name", "2");
        assertEquals("2", obj.getMetadata("My-name"));
        assertEquals("2", obj.getMetadata("My-Name"));
        assertEquals("2", obj.getMetadata("my-name"));

        // Null metadata names are allowed (though a bad idea...)
        obj.addMetadata(null, "3");
        assertEquals("3", obj.getMetadata(null));
        obj.addMetadata(null, "4");
        assertEquals("4", obj.getMetadata(null));

        // Last add operation with matching case-insensitive name wins
        obj.addMetadata("CaseInsensitive", "5");
        obj.addMetadata("Caseinsensitive", "6");
        obj.addMetadata("caseinsensitive", "7");
        obj.addMetadata("CASEINSENSITIVE", "8");
        assertEquals("8", obj.getMetadata("CaseInsensitive"));

        // Remove item is also case-insensitive
        assertEquals(3, obj.getMetadataMap().size()); // Items added so far
        obj.removeMetadata("my-namE");
        obj.removeMetadata(null);
        obj.removeMetadata("CASEinsensitive");

        // Add all
        Map<String, Object> newMetadata = new HashMap<String, Object>();
        newMetadata.put("FIRST", "1st");
        newMetadata.put("second", "2nd");
        newMetadata.put("thIrd", "3rd");
        obj.addAllMetadata(newMetadata);
        assertEquals("1st", obj.getMetadata("first"));
        assertEquals("2nd", obj.getMetadata("SECOND"));
        assertEquals("3rd", obj.getMetadata("THiRD"));

        // Replace all
        newMetadata = new HashMap<String, Object>();
        newMetadata.put("one", "1st");
        newMetadata.put("TWO", "2nd");
        newMetadata.put("THRee", "3rd");
        obj.replaceAllMetadata(newMetadata);
        assertEquals(3, obj.getMetadataMap().size());
        assertEquals("1st", obj.getMetadata("ONE"));
        assertEquals("2nd", obj.getMetadata("two"));
        assertEquals("3rd", obj.getMetadata("thrEE"));
    }
View Full Code Here

            // Put the object in S3 using the signed URL (no AWS credentials required)
            RestS3Service restS3Service = new RestS3Service(null);
            restS3Service.putObjectWithSignedUrl(signedPutUrl, object);

            // Ensure the object was created.
            StorageObject objects[] = service.listObjects(bucketName, object.getKey(), null);
            assertEquals("Signed PUT URL failed to put/create object", objects.length, 1);

            // Change the object's content-type and ensure the signed PUT URL disallows the put.
            object.setContentType("application/octet-stream");
            try {
View Full Code Here

TOP

Related Classes of org.jets3t.service.model.StorageObject

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.