Examples of org.jets3t.service.impl.rest.httpclient.RestStorageService

Package org.jets3t.service.impl.rest.httpclient

Examples of org.jets3t.service.impl.rest.httpclient.RestStorageService

org.jets3t.service.impl.rest.httpclient.RestStorageService
ta.apache.org/commons/httpclient/">HttpClient library.
This class uses properties obtained through {@link org.jets3t.service.Jets3tProperties}. For more information on these properties please refer to JetS3t Configuration
@author James Murty, Google Developers

        }
    }


    public void testACLManagement() throws Exception {
        // Access public-readable third-party bucket: jets3t
        RestStorageService anonymousS3Service = getStorageService(null);
        boolean jets3tBucketAvailable = anonymousS3Service.isBucketAccessible("jets3t");
        assertTrue("Cannot find public jets3t bucket", jets3tBucketAvailable);


        RestStorageService service = getStorageService(getCredentials());


        // Use Google- or S3-specific URL endpoint to lookup objects, depending on the target service
        String linkUrlPrefix = null;
        if (TARGET_SERVICE_GS.equals(getTargetService())) {
            linkUrlPrefix = "https://commondatastorage.googleapis.com";
        } else {
            linkUrlPrefix = "https://s3.amazonaws.com";
        }
        // Use Google- or S3-specific ACL elements depending on which service class we're using
        GranteeInterface allUsersGrantee = null;
        if (service instanceof GoogleStorageService) {
            allUsersGrantee = new AllUsersGrantee();
        } else {
            allUsersGrantee = GroupGrantee.ALL_USERS;
        }


        StorageBucket bucket = createBucketForTest("testACLManagement");
        String bucketName = bucket.getName();
        StorageObject object = null;


        try {
            // Create private object (default permissions).
            String privateKey = "Private Object - " + System.currentTimeMillis();
            object = new StorageObject(privateKey, "Private object sample text");
            service.putObject(bucketName, object);
            URL url = new URL(linkUrlPrefix + "/" + bucketName + "/" + RestUtils.encodeUrlString(privateKey));
            assertEquals("Expected denied access (403) error", 403, ((HttpURLConnection) url
                .openConnection()).getResponseCode());


            // Get ACL details for private object so we can determine the account owner ID.
            AccessControlList objectACL = service.getObjectAcl(bucketName, privateKey);
            StorageOwner accountOwner = objectACL.getOwner();


            // Create a public object.
            String publicKey = "Public Object - " + System.currentTimeMillis();
            object = new StorageObject(publicKey, "Public object sample text");
            AccessControlList acl = buildAccessControlList();
            acl.setOwner(accountOwner);
            acl.grantPermission(allUsersGrantee, Permission.PERMISSION_READ);
            object.setAcl(acl);
            service.putObject(bucketName, object);
            url = new URL(linkUrlPrefix + "/" + bucketName + "/" + RestUtils.encodeUrlString(publicKey));
            assertEquals("Expected access (200)",
                    200, ((HttpURLConnection)url.openConnection()).getResponseCode());


            // Update ACL to make private object public.
            AccessControlList privateToPublicACL = service.getObjectAcl(bucketName, privateKey);
            privateToPublicACL.grantPermission(allUsersGrantee, Permission.PERMISSION_READ);
            object.setKey(privateKey);
            object.setAcl(privateToPublicACL);
            service.putObjectAcl(bucketName, object);
            url = new URL(linkUrlPrefix + "/" + bucketName + "/" + RestUtils.encodeUrlString(privateKey));
            assertEquals("Expected access (200)", 200, ((HttpURLConnection) url.openConnection())
                .getResponseCode());


            // Create a non-standard uncanned public object.
            String publicKey2 = "Public Object - " + System.currentTimeMillis();
            object = new StorageObject(publicKey2);
            object.setAcl(privateToPublicACL); // This ACL has ALL_USERS READ permission set above.
            service.putObject(bucketName, object);
            url = new URL(linkUrlPrefix + "/" + bucketName + "/" + RestUtils.encodeUrlString(publicKey2));
            assertEquals("Expected access (200)", 200, ((HttpURLConnection) url.openConnection())
                .getResponseCode());


            // Update ACL to make public object private.
            AccessControlList publicToPrivateACL = service.getObjectAcl(bucketName, publicKey);
            publicToPrivateACL.revokeAllPermissions(allUsersGrantee);
            object.setKey(publicKey);
            object.setAcl(publicToPrivateACL);
            service.putObjectAcl(bucketName, object);
            // TODO: Google Storage quirk: It may take some time for public object to become private again
            if (TARGET_SERVICE_GS.equals(getTargetService())) {
                // Confirm changes were applied on object's ACL, because we don't know
                // how long to wait until the object will really become private again.
                AccessControlList updatedAcl = service.getObjectAcl(bucketName, object.getKey());
                assertFalse(updatedAcl.hasGranteeAndPermission(
                    allUsersGrantee, Permission.PERMISSION_READ));
                assertEquals(0, updatedAcl.getPermissionsForGrantee(allUsersGrantee).size());
            } else {
                // In S3, objects are made private immediately.
                url = new URL(linkUrlPrefix + "/" + bucketName + "/" + RestUtils.encodeUrlString(publicKey));
                assertEquals("Expected denied access (403) error", 403, ((HttpURLConnection) url
                    .openConnection()).getResponseCode());
            }


            // Clean-up.
            service.deleteObject(bucketName, privateKey);
            service.deleteObject(bucketName, publicKey);
            service.deleteObject(bucketName, publicKey2);
        } finally {
            cleanupBucketForTest("testACLManagement");
        }
    }

View Full Code Here

            cleanupBucketForTest("testACLManagement");
        }
    }


    public void testACLManagementViaRestHeaders() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testACLManagementViaRestHeaders");


        AccessControlList publicHeaderAcl = null;
        if (service instanceof GoogleStorageService) {
            publicHeaderAcl = GSAccessControlList.REST_CANNED_PUBLIC_READ;
        } else {
            publicHeaderAcl = AccessControlList.REST_CANNED_PUBLIC_READ;
        }


        try {
            // Try to create public object using HTTP header ACL settings.
            String publicKey = "PublicObject";
            StorageObject object = new StorageObject(publicKey);
            object.setAcl(publicHeaderAcl);
            object.setOwner(bucket.getOwner());


            try {
                service.putObject(bucket.getName(), object);
                URL url = new URL("https://" + service.getEndpoint()
                    + "/" + bucket.getName() + "/" + publicKey);
                assertEquals("Expected public access (200)",
                        200, ((HttpURLConnection)url.openConnection()).getResponseCode());
            } finally {
                service.deleteObject(bucket.getName(), object.getKey());
            }
        } finally {
            cleanupBucketForTest("testACLManagementViaRestHeaders");
        }
    }

View Full Code Here

            cleanupBucketForTest("testACLManagementViaRestHeaders");
        }
    }


    public void testObjectListing() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testObjectListing");
        String bucketName = bucket.getName();


        try {
            // Represent a directory structure in S3.
            List<StorageObject> objectsList = new ArrayList<StorageObject>();
            objectsList.add(new StorageObject("dir1"));
            objectsList.add(new StorageObject("dir1/doc1Level1"));
            objectsList.add(new StorageObject("dir1/doc2level1"));
            objectsList.add(new StorageObject("dir1/dir1Level1"));
            objectsList.add(new StorageObject("dir1/dir1Level1/doc1Level2"));
            objectsList.add(new StorageObject("dir1/dir1Level1/dir1Level2"));
            objectsList.add(new StorageObject("dir1/dir1Level1/dir1Level2/doc1Level3"));


            // Create objects
            for (StorageObject object: objectsList) {
                service.putObject(bucketName, object);
            }


            StorageObject[] objects = null;


            // List all items in directory.
            objects = service.listObjects(bucketName);
            assertEquals("Incorrect number of objects in directory structure",
                objectsList.size(), objects.length);


            // Check all objects have bucket name property set
            for (StorageObject object: objects) {
                assertEquals(bucketName, object.getBucketName());
            }


            // List items in chunks of size 2, ensure we get a total of seven.
            int chunkedObjectsCount = 0;
            int chunkedIterationsCount = 0;
            String priorLastKey = null;
            do {
                StorageObjectsChunk chunk = service.listObjectsChunked(
                    bucketName, null, null, 2, priorLastKey);
                priorLastKey = chunk.getPriorLastKey();
                chunkedObjectsCount += chunk.getObjects().length;
                chunkedIterationsCount++;
            } while (priorLastKey != null);
            assertEquals("Chunked bucket listing retreived incorrect number of objects",
                objectsList.size(), chunkedObjectsCount);
            assertEquals("Chunked bucket listing ran for an unexpected number of iterations",
                (objectsList.size() + 1) / 2, chunkedIterationsCount);


            // List objects with a prefix and delimiter to check common prefixes.
            StorageObjectsChunk chunk = service.listObjectsChunked(
                bucketName, "dir1/", "/", 100, null);
            assertEquals("Chunked bucket listing with prefix and delimiter retreived incorrect number of objects",
                3, chunk.getObjects().length);
            assertEquals("Chunked bucket listing with prefix and delimiter retreived incorrect number of common prefixes",
                1, chunk.getCommonPrefixes().length);


            // List the same items with a prefix.
            objects = service.listObjects(bucketName, "dir1", null);
            assertEquals("Incorrect number of objects matching prefix", 7, objects.length);


            // List items up one directory with a prefix (will include dir1Level1)
            objects = service.listObjects(bucketName, "dir1/dir1Level1", null);
            assertEquals("Incorrect number of objects matching prefix", 4, objects.length);


            // List items up one directory with a prefix (will not include dir1Level1)
            objects = service.listObjects(bucketName, "dir1/dir1Level1/", null);
            assertEquals("Incorrect number of objects matching prefix", 3, objects.length);


            // Try a prefix matching no object keys.
            objects = service.listObjects(bucketName, "dir1-NonExistent", null);
            assertEquals("Expected no results", 0, objects.length);


            // Use delimiter with an partial prefix.
            objects = service.listObjects(bucketName, "dir", "/");
            assertEquals("Expected no results", 1, objects.length);


            // Use delimiter to find item dir1 only.
            objects = service.listObjects(bucketName, "dir1", "/");
            assertEquals("Incorrect number of objects matching prefix and delimiter", 1, objects.length);


            // Use delimiter to find items within dir1 only.
            objects = service.listObjects(bucketName, "dir1/", "/");
            assertEquals("Incorrect number of objects matching prefix and delimiter", 3, objects.length);


            // List items up one directory with prefix and delimiter (will include only dir1Level1)
            objects = service.listObjects(bucketName, "dir1/dir1Level1", "/");
            assertEquals("Incorrect number of objects matching prefix", 1, objects.length);


            // List items up one directory with prefix and delimiter (will include only contents of dir1Level1)
            objects = service.listObjects(bucketName, "dir1/dir1Level1/", "/");
            assertEquals("Incorrect number of objects matching prefix", 2, objects.length);


            // Clean up.
            for (StorageObject object: objectsList) {
                service.deleteObject(bucketName, object.getKey());
            }
        } finally {
            cleanupBucketForTest("testObjectListing");
        }
    }

View Full Code Here

            cleanupBucketForTest("testObjectListing");
        }
    }


    public void testHashVerifiedUploads() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testHashVerifiedUploads");
        String bucketName = bucket.getName();


        try {
            // Create test object with an MD5 hash of the data.
            String dataString = "Text for MD5 hashing...";
            StorageObject object = new StorageObject("Testing MD5 Hashing", dataString);
            object.setContentType("text/plain");


            // Calculate hash data for object.
            byte[] md5Hash = ServiceUtils.computeMD5Hash(dataString.getBytes());


            // Ensure that using an invalid hash value fails.
            try {
                object.addMetadata("Content-MD5", "123");
                service.putObject(bucketName, object);
                fail("Should have failed due to invalid hash value");
            } catch (ServiceException e) {
                assertTrue("Expected error code indicating invalid md5 hash",
                    "InvalidDigest".equals(e.getErrorCode())  // S3 error code
                    || "BadDigest".equals(e.getErrorCode())   // GS error code
                    );
            }
            object = new StorageObject("Testing MD5 Hashing", dataString);


            // Ensure that using the wrong hash value fails.
            try {
                byte[] incorrectHash = new byte[md5Hash.length];
                System.arraycopy(md5Hash, 0, incorrectHash, 0, incorrectHash.length);
                incorrectHash[0] = incorrectHash[1];
                object.setMd5Hash(incorrectHash);
                service.putObject(bucketName, object);
                fail("Should have failed due to incorrect hash value");
            } catch (ServiceException e) {
                assertEquals("Expected error code indicating invalid md5 hash", "BadDigest", e.getErrorCode());
            }
            object = new StorageObject("Testing MD5 Hashing", dataString);


            // Ensure that correct hash value succeeds.
            object.setMd5Hash(md5Hash);
            StorageObject resultObject = service.putObject(bucketName, object);


            // Ensure the ETag result matches the hex-encoded MD5 hash.
            assertEquals("Hex-encoded MD5 hash should match ETag", resultObject.getETag(),
                ServiceUtils.toHex(md5Hash));


            // Ensure we can convert the hex-encoded ETag to Base64 that matches the Base64 md5 hash.
            String md5HashBase64 = ServiceUtils.toBase64(md5Hash);
            String eTagBase64 = ServiceUtils.toBase64(ServiceUtils.fromHex(resultObject.getETag()));
            assertEquals("Could not convert ETag and MD5 hash to matching Base64-encoded strings",
                md5HashBase64, eTagBase64);


            // Clean up.
            service.deleteObject(bucketName, object.getKey());
        } finally {
            cleanupBucketForTest("testHashVerifiedUploads");
        }
    }

View Full Code Here

            cleanupBucketForTest("testHashVerifiedUploads");
        }
    }


    public void testIsObjectInBucket() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testIsObjecInBucket");
        String bucketName = bucket.getName();


        try {
            service.putObject(bucketName, new StorageObject("does-exist"));


            assertTrue(service.isObjectInBucket(bucketName, "does-exist"));


            assertFalse(service.isObjectInBucket(bucketName, "does-not-exist"));
        } finally {
            cleanupBucketForTest("testIsObjecInBucket");
        }
    }

View Full Code Here

            cleanupBucketForTest("testIsObjecInBucket");
        }
    }


    public void testThreadedStorageService() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testThreadedStorageService");
        String bucketName = bucket.getName();


        try {
            final int[] createObjectsEventCount = new int[] {0};
            final int[] getObjectHeadsEventCount = new int[] {0};
            final List<StorageObject> getObjectsList = new ArrayList<StorageObject>();
            final int[] deleteObjectsEventCount = new int[] {0};


            // Multi-threaded service with adaptor to count event occurrences.
            ThreadedStorageService threadedService = new ThreadedStorageService(
                service,
                new StorageServiceEventAdaptor() {
                    @Override
                    public void event(CreateObjectsEvent event) {
                        if (CreateObjectsEvent.EVENT_IN_PROGRESS == event.getEventCode()) {
                            createObjectsEventCount[0] += event.getCreatedObjects().length;
                        }
                    }


                    @Override
                    public void event(GetObjectHeadsEvent event) {
                        if (GetObjectHeadsEvent.EVENT_IN_PROGRESS == event.getEventCode()) {
                            getObjectHeadsEventCount[0] += event.getCompletedObjects().length;
                        }
                    }


                    @Override
                    public void event(GetObjectsEvent event) {
                        if (GetObjectsEvent.EVENT_IN_PROGRESS == event.getEventCode()) {
                            for (StorageObject object: event.getCompletedObjects()) {
                                getObjectsList.add(object);
                            }
                        }
                    }


                    @Override
                    public void event(DeleteObjectsEvent event) {
                        if (DeleteObjectsEvent.EVENT_IN_PROGRESS == event.getEventCode()) {
                            deleteObjectsEventCount[0] += event.getDeletedObjects().length;
                        }
                    }
            });


            assertEquals(0, createObjectsEventCount[0]);
            assertEquals(0, getObjectHeadsEventCount[0]);
            assertEquals(0, getObjectsList.size());
            assertEquals(0, deleteObjectsEventCount[0]);


            StorageObject[] objects = new StorageObject[] {
                new StorageObject("one.txt", "Some data"),
                new StorageObject("twö.txt", "Some data"),
                new StorageObject("thréè.txt", "Some data"),
                new StorageObject("fôür.txt", "Some data"),
                new StorageObject("fîvæ∫.txt", "Some data")
            };


            // Upload multiple objects
            boolean success = threadedService.putObjects(bucketName, objects);
            assertTrue(success);
            assertEquals(objects.length, createObjectsEventCount[0]);
            assertEquals(0, getObjectHeadsEventCount[0]);
            assertEquals(0, getObjectsList.size());
            assertEquals(0, deleteObjectsEventCount[0]);


            // Retrieve details for multiple objects
            success = threadedService.getObjectsHeads(bucketName, objects);
            assertTrue(success);
            assertEquals(objects.length, createObjectsEventCount[0]);
            assertEquals(objects.length, getObjectHeadsEventCount[0]);
            assertEquals(0, getObjectsList.size());
            assertEquals(0, deleteObjectsEventCount[0]);


            // Retrieve data for multiple objects
            success = threadedService.getObjects(bucketName, objects);
            assertTrue(success);
            assertEquals(objects.length, createObjectsEventCount[0]);
            assertEquals(objects.length, getObjectHeadsEventCount[0]);
            assertEquals(objects.length, getObjectsList.size());
            assertEquals(0, deleteObjectsEventCount[0]);
            // Check all objects retrieved have expected data content.
            for (StorageObject getObject: getObjectsList) {
                // TODO: Google Storage doesn't reliably return Content-Length in a GET
                if (!TARGET_SERVICE_GS.equals(getTargetService())) {
                    assertEquals("Some data".length(), getObject.getContentLength());
                }
                String objectData = ServiceUtils.readInputStreamToString(
                    getObject.getDataInputStream(), Constants.DEFAULT_ENCODING);
                assertEquals("Some data", objectData);
            }


            // Delete multiple objects
            success = threadedService.deleteObjects(bucketName, objects);
            assertTrue(success);
            assertEquals(objects.length, createObjectsEventCount[0]);
            assertEquals(objects.length, getObjectHeadsEventCount[0]);
            assertEquals(objects.length, getObjectsList.size());
            assertEquals(objects.length, deleteObjectsEventCount[0]);


            StorageObject[] listedObjects = service.listObjects(bucketName);
            assertEquals(0, listedObjects.length);
        } finally {
            cleanupBucketForTest("testThreadedStorageService");
        }
    }

View Full Code Here

            cleanupBucketForTest("testThreadedStorageService");
        }
    }


    public void testSimpleThreadedStorageService() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testSimpleThreadedStorageService");
        String bucketName = bucket.getName();


        try {
            SimpleThreadedStorageService simpleThreadedService =
                new SimpleThreadedStorageService(service);


            StorageObject[] objects = new StorageObject[] {
                new StorageObject("1-one.txt", "Some data"),
                new StorageObject("2-twö.txt", "Some data"),
                new StorageObject("3-thréè.txt", "Some data"),
                new StorageObject("4-fôür.txt", "Some data"),
                new StorageObject("5-fîvæ∫.txt", "Some data")
            };


            // Upload multiple objects
            StorageObject[] putObjects =
                simpleThreadedService.putObjects(bucketName, objects);
            StorageObject[] listedObjects = service.listObjects(bucketName);
            assertEquals(objects.length, listedObjects.length);


            // Retrieve details for multiple objects
            StorageObject[] headObjects = simpleThreadedService.getObjectsHeads(bucketName, objects);
            assertEquals(objects.length, headObjects.length);
            Arrays.sort(headObjects, new Comparator<StorageObject>() {
                public int compare(StorageObject o1, StorageObject o2) {
                    return o1.getKey().compareTo(o2.getKey());
                }
            });
            for (int i = 0; i < objects.length; i++) {
                assertEquals(objects[i].getKey(), headObjects[i].getKey());
                assertEquals("Some data".length(), headObjects[i].getContentLength());
            }


            // Retrieve details for objects, some of which are missing but which we don't
            // want to cause an error.
            class Http404ErrorPermitter extends ErrorPermitter {
                @Override
                public boolean isPermitted(ServiceException ex) {
                    return ex.getResponseCode() == 404;
                }
            }
            // Prepare object keys combining existing and non-existent key names
            String objectKeys[] = new String[objects.length + 2];
            for (int i = 0; i < objects.length; i++) {
                objectKeys[i] = objects[i].getKey();
            }
            objectKeys[objects.length] = "missing-object-key-1";
            objectKeys[objects.length + 1] = "missing-object-key-2";
            StorageObject[] headObjectsWithMissing = simpleThreadedService.getObjectsHeads(
                bucketName, objectKeys, new Http404ErrorPermitter());
            assertEquals(objects.length + 2, headObjectsWithMissing.length);
            for (int i = 0; i < objects.length; i++) {
                assertEquals(objects[i].getKey(), headObjectsWithMissing[i].getKey());
                assertEquals("Some data".length(), headObjectsWithMissing[i].getContentLength());
            }
            // Ensure we got ThrowableBearingStorageObject results with relevant info
            assertEquals("missing-object-key-1", headObjectsWithMissing[objects.length].getKey());
            assertEquals("missing-object-key-2", headObjectsWithMissing[objects.length + 1].getKey());
            for (int i = objects.length; i < objects.length + 2; i++) {
                assertEquals(
                    ThrowableBearingStorageObject.class, headObjectsWithMissing[i].getClass());
                assertEquals(404,
                    ((ServiceException)
                        ((ThrowableBearingStorageObject)headObjectsWithMissing[i])
                        .getThrowable()).getResponseCode());
            }


            // Retrieve data for multiple objects
            StorageObject[] getObjects = simpleThreadedService.getObjects(bucketName, objects);
            assertEquals(objects.length, getObjects.length);
            for (int i = 0; i < objects.length; i++) {
                // TODO: Google Storage doesn't reliably return Content-Length in a GET
                if (!TARGET_SERVICE_GS.equals(getTargetService())) {
                    assertEquals("Some data".length(), getObjects[i].getContentLength());
                }
                // Check all objects retrieved have expected data content.
                assertEquals("Some data", ServiceUtils.readInputStreamToString(
                    getObjects[i].getDataInputStream(), Constants.DEFAULT_ENCODING));
            }


            // Delete multiple objects
            simpleThreadedService.deleteObjects(bucketName, objects);
            listedObjects = service.listObjects(bucketName);
            assertEquals(0, listedObjects.length);
        } finally {
            cleanupBucketForTest("testSimpleThreadedStorageService");
        }
    }

View Full Code Here

        assertFalse(ServiceUtils.isBucketNameValidDNSName("10.0.0.1"));
    }




    public void testFileComparer() throws Exception {
        RestStorageService service = getStorageService(getCredentials());
        StorageBucket bucket = createBucketForTest("testFileComparer");
        String bucketName = bucket.getName();
        try {
            // Create temporary file and directory structure
            File dummy = File.createTempFile("dummy-", ".txt");
            File rootDir = new File(dummy.getParentFile(), "jets3t-test-" + dummy.getName());
            File parentDir1 = new File(rootDir, "dir1");
            File parentDir2 = new File(rootDir, "dir2");
            parentDir1.mkdirs();
            parentDir2.mkdirs();
            File local1 = File.createTempFile("one", ".txt", parentDir1);
            File local2 = File.createTempFile("two", ".txt", parentDir1);
            File local3 = File.createTempFile("three", " ثلاثة.txt", parentDir2);
            String local1Path = parentDir1.getName() + File.separator + local1.getName();
            String local2Path = parentDir1.getName() + File.separator + local2.getName();
            String local3Path = parentDir2.getName() + File.separator + local3.getName();


            FileComparer comparer = new FileComparer(new Jets3tProperties());
            // Build a file map of local files
            Map<String, String> objectKeyToFilepathMap = comparer.buildObjectKeyToFilepathMap(
                new File[] {parentDir1, parentDir2}, "", true);
            assertEquals(5, objectKeyToFilepathMap.size());
            assertTrue(objectKeyToFilepathMap.keySet().contains(local1Path));


            // Upload local directories and files to storage service
            service.putObject(bucketName, ObjectUtils.createObjectForUpload(
                parentDir1.getName() + "/", parentDir1, null, false));
            service.putObject(bucketName, ObjectUtils.createObjectForUpload(
                parentDir2.getName() + "/", parentDir2, null, false));
            service.putObject(bucketName, ObjectUtils.createObjectForUpload(
                local1Path, local1, null, false));
            service.putObject(bucketName, ObjectUtils.createObjectForUpload(
                local2Path, local2, null, false));
            service.putObject(bucketName, ObjectUtils.createObjectForUpload(
                local3Path, local3, null, false));


            // Build a map of objects in storage service
            Map<String, StorageObject> objectMap = comparer.buildObjectMap(
                service, bucket.getName(), "", objectKeyToFilepathMap, false, false, null, null);
            assertEquals(5, objectMap.size());
            assertTrue(objectMap.keySet().contains(local3Path));


            // Compare local and remote objects -- should be identical
            FileComparerResults comparerResults =
                comparer.buildDiscrepancyLists(objectKeyToFilepathMap, objectMap);
            assertEquals(5, comparerResults.alreadySynchronisedKeys.size());
            assertEquals(0, comparerResults.onlyOnClientKeys.size());
            assertEquals(0, comparerResults.onlyOnServerKeys.size());
            assertEquals(0, comparerResults.updatedOnClientKeys.size());
            assertEquals(0, comparerResults.updatedOnServerKeys.size());


            // Update 1 local and 1 remote file, then confirm discrepancies
            byte[] data = "Updated local file".getBytes("UTF-8");
            FileOutputStream local1FOS = new FileOutputStream(local1);
            local1FOS.write(data);
            local1FOS.close();
            // Ensure local file's timestamp differs by at least 1 sec
            local1.setLastModified(local1.lastModified() + 1000);


            data = "Updated remote file".getBytes("UTF-8");
            StorageObject remoteObject = new StorageObject(local3Path);
            // Ensure remote file's JetS3t timestamp differs from local file by at least 1 sec
            remoteObject.addMetadata(Constants.METADATA_JETS3T_LOCAL_FILE_DATE,
                ServiceUtils.formatIso8601Date(new Date(local3.lastModified() + 1000)));
            remoteObject.setDataInputStream(new ByteArrayInputStream(data));
            remoteObject.setContentLength(data.length);
            service.putObject(bucketName, remoteObject);


            objectMap = comparer.buildObjectMap(
                service, bucket.getName(), "", objectKeyToFilepathMap, false, false, null, null);


            comparerResults =
                comparer.buildDiscrepancyLists(objectKeyToFilepathMap, objectMap);
            assertEquals(3, comparerResults.alreadySynchronisedKeys.size());
            assertEquals(0, comparerResults.onlyOnClientKeys.size());
            assertEquals(0, comparerResults.onlyOnServerKeys.size());
            assertEquals(1, comparerResults.updatedOnClientKeys.size());
            assertTrue(comparerResults.updatedOnClientKeys.contains(local1Path));
            assertEquals(1, comparerResults.updatedOnServerKeys.size());
            assertTrue(comparerResults.updatedOnServerKeys.contains(local3Path));


            // Create new local and remote objects, then confirm discrepancies
            File local4 = File.createTempFile("four", ".txt", parentDir2);
            String local4Path = parentDir2.getName() + File.separator + local4.getName();
            remoteObject = new StorageObject("new-on-service.txt");
            service.putObject(bucketName, remoteObject);


            objectKeyToFilepathMap = comparer.buildObjectKeyToFilepathMap(
                new File[] {parentDir1, parentDir2}, "", true);
            objectMap = comparer.buildObjectMap(
                service, bucket.getName(), "", objectKeyToFilepathMap, false, false, null, null);


            comparerResults = comparer.buildDiscrepancyLists(objectKeyToFilepathMap, objectMap);
            assertEquals(3, comparerResults.alreadySynchronisedKeys.size());
            assertTrue(comparerResults.alreadySynchronisedKeys.contains(local2Path));
            assertEquals(1, comparerResults.onlyOnClientKeys.size());
            assertTrue(comparerResults.onlyOnClientKeys.contains(local4Path));
            assertEquals(1, comparerResults.onlyOnServerKeys.size());
            assertTrue(comparerResults.onlyOnServerKeys.contains("new-on-service.txt"));
            assertEquals(1, comparerResults.updatedOnClientKeys.size());
            assertTrue(comparerResults.updatedOnClientKeys.contains(local1Path));
            assertEquals(1, comparerResults.updatedOnServerKeys.size());
            assertTrue(comparerResults.updatedOnServerKeys.contains(local3Path));


            // Clean up after prior test
            local4.delete();
            service.deleteObject(bucketName, "new-on-service.txt");


            // Remove local file and remote object, then confirm discrepancies
            local3.delete();
            service.deleteObject(bucketName, local1Path);


            objectKeyToFilepathMap = comparer.buildObjectKeyToFilepathMap(
                new File[] {parentDir1, parentDir2}, "", true);
            objectMap = comparer.buildObjectMap(
                service, bucket.getName(), "", objectKeyToFilepathMap, false, false, null, null);

View Full Code Here

        }
    }


    protected void deleteAllObjectsInBucket(String bucketName) {
        try {
            RestStorageService service = getStorageService(getCredentials());
            for (StorageObject o: service.listObjects(bucketName)) {
                service.deleteObject(bucketName, o.getKey());
            }
        } catch (Exception e) {
            // This shouldn't happen, but if it does don't ruin the test
            e.printStackTrace();
        }

View Full Code Here

        }
    }


    protected void cleanupBucketForTest(String testName, boolean deleteAllObjects) {
        try {
            RestStorageService service = getStorageService(getCredentials());
            String bucketName = getBucketNameForTest(testName);


            if (deleteAllObjects) {
                deleteAllObjectsInBucket(bucketName);
            }


            service.deleteBucket(bucketName);
        } catch (Exception e) {
            // This shouldn't happen, but if it does don't ruin the test
            e.printStackTrace();
        }
    }

View Full Code Here

0 1

TOP

Related Classes of org.jets3t.service.impl.rest.httpclient.RestStorageService

org.apache.http.client.methods.HttpDelete

org.apache.http.client.methods.HttpGet

org.apache.http.client.methods.HttpHead

org.apache.http.client.methods.HttpPost

org.apache.http.client.methods.HttpPut

org.apache.http.client.methods.HttpRequestBase

org.apache.http.client.methods.HttpUriRequest

org.apache.http.conn.ClientConnectionManager

org.apache.http.entity.BasicHttpEntity

org.apache.http.entity.BufferedHttpEntity

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.