Java CannedAccessControlList類代碼示例

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
/**
 * Upload a file which is in the assets bucket.
 * 
 * @param fileName File name
 * @param file File
 * @param contentType Content type for file
 * @return
 */
public static boolean uploadFile(String fileName, File file, String contentType) {
    try {
        if (S3Module.amazonS3 != null) {
            String bucket = S3Module.s3Bucket;
            ObjectMetadata metaData = new ObjectMetadata();
            if (contentType != null) {
                metaData.setContentType(contentType);
            }
            PutObjectRequest putObj = new PutObjectRequest(bucket,
                    fileName, file);
            putObj.setMetadata(metaData);
            putObj.withCannedAcl(CannedAccessControlList.PublicRead);
            S3Module.amazonS3.putObject(putObj);
            return true;
        } else {
            Logger.error("Could not save because amazonS3 was null");
            return false;
        }
    } catch (Exception e) {
        Logger.error("S3 Upload -" + e.getMessage());
        return false;
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
public static void uploadToS3() {
    // upload to s3 bucket
    AWSCredentials awsCredentials = SkillConfig.getAWSCredentials();
    AmazonS3Client s3Client = awsCredentials != null ? new AmazonS3Client(awsCredentials) : new AmazonS3Client();

    File folder = new File("c:/temp/morse/" + DOT + "/mp3/");
    File[] listOfFiles = folder.listFiles();

    for (File file : listOfFiles) {
        if (file.isFile()) {
            if (!s3Client.doesObjectExist("morseskill", DOT + "/" + file.getName())) {
                PutObjectRequest s3Put = new PutObjectRequest("morseskill", DOT + "/" + file.getName(), file).withCannedAcl(CannedAccessControlList.PublicRead);
                s3Client.putObject(s3Put);
                System.out.println("Upload complete: " + file.getName());
            }
            else {
                System.out.println("Skip as " + file.getName() + " already exists.");
            }
        }
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
/**
 * The method creates a short URL code for the given url
 * 
 * @param url
 * @return
 */
public ShortUrl createShortUrl(String url, String code) {

	logger.info("storing the url {} in the bucket {}", url, this.bucket);
	// Create the link for the short code
	if (code == null) {
		code = getObjectCode();
	}
	String loadFile = redirectFile.replace("REPLACE", url);
	byte[] fileContentBytes = loadFile.getBytes(StandardCharsets.UTF_8);
	InputStream fileInputStream = new ByteArrayInputStream(fileContentBytes);
	ObjectMetadata metadata = new ObjectMetadata();
	metadata.setContentType("text/html");
	metadata.addUserMetadata("url", url);
	metadata.setContentLength(fileContentBytes.length);
	PutObjectRequest putObjectRequest = new PutObjectRequest(this.bucket, code, fileInputStream, metadata)
			.withCannedAcl(CannedAccessControlList.PublicRead);
	this.s3Client.putObject(putObjectRequest);
	createDummyRecord(url, code);
	return new ShortUrl(url, code);
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
@Override
public void setBucketAcl(SetBucketAclRequest setBucketAclRequest)
        throws SdkClientException, AmazonServiceException {
    setBucketAclRequest = beforeClientExecution(setBucketAclRequest);

    String bucketName = setBucketAclRequest.getBucketName();
    rejectNull(bucketName, "The bucket name parameter must be specified when setting a bucket's ACL");

    AccessControlList acl = setBucketAclRequest.getAcl();
    CannedAccessControlList cannedAcl = setBucketAclRequest.getCannedAcl();

    if (acl == null && cannedAcl == null) {
        throw new IllegalArgumentException(
                "The ACL parameter must be specified when setting a bucket's ACL");
    }
    if (acl != null && cannedAcl != null) {
        throw new IllegalArgumentException(
                "Only one of the acl and cannedAcl parameter can be specified, not both.");
    }

    if (acl != null) {
        setAcl(bucketName, null, null, acl, false, setBucketAclRequest);
    } else {
        setAcl(bucketName, null, null, cannedAcl, false, setBucketAclRequest);
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
public String uploadImageToS3(final BufferedImage image, final String fileKey) throws IOException {
    ByteArrayInputStream bis = null;
    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        ImageIO.write(image, "png", bos);
        final byte[] bImageData = bos.toByteArray();
        bis = new ByteArrayInputStream(bImageData);
        // upload to s3 bucket
        final PutObjectRequest s3Put = new PutObjectRequest(bucket, fileKey, bis, null).withCannedAcl(CannedAccessControlList.PublicRead);
        s3Client.putObject(s3Put);
        return getS3Url(fileKey);
    } finally {
        try {
            bos.close();
            if (bis != null) bis.close();
        }
        catch(IOException e) {
            logger.severe("Error while closing stream for writing an image for " + fileKey + " caused by " + e.getMessage());
        }
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
protected static String uploadFileToS3(BufferedImage image, String word, Boolean codeOnly) throws IOException {
    ByteArrayInputStream bis = null;
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        String bucket = SkillConfig.getS3BucketName();
        String fileKey = getFileKey(word, codeOnly);
        ImageIO.write(image, "png", bos);
        byte[] bImageData = bos.toByteArray();
        bis = new ByteArrayInputStream(bImageData);
        // upload to s3 bucket
        AWSCredentials awsCredentials = SkillConfig.getAWSCredentials();
        AmazonS3Client s3Client = awsCredentials != null ? new AmazonS3Client(awsCredentials) : new AmazonS3Client();
        PutObjectRequest s3Put = new PutObjectRequest(bucket, fileKey, bis, null).withCannedAcl(CannedAccessControlList.PublicRead);
        s3Client.putObject(s3Put);
        return getS3Url(word, codeOnly);
    } finally {
        bos.close();
        if (bis != null) bis.close();
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
@Override
public PutObjectResult uploadObject(final String bucketName, final String fileName, final InputStream inputStream,
		final CannedAccessControlList cannedAcl) throws AmazonClientException, AmazonServiceException, IOException {
	LOGGER.info("uploadObject invoked, bucketName: {} , fileName: {}, cannedAccessControlList: {}", bucketName, fileName, cannedAcl);
	File tempFile = null;
	PutObjectRequest putObjectRequest = null;
	PutObjectResult uploadResult = null;
	try {
		// Create temporary file from stream to avoid 'out of memory' exception
		tempFile = AWSUtil.createTempFileFromStream(inputStream);
		putObjectRequest = new PutObjectRequest(bucketName, fileName, tempFile).withCannedAcl(cannedAcl);
		uploadResult = uploadObject(putObjectRequest);
	} finally {
		AWSUtil.deleteTempFile(tempFile); // Delete the temporary file once uploaded
	}
	return uploadResult;
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
@Override
public PutObjectResult createDirectory(final String bucketName, final String dirName,
		final boolean isPublicAccessible) throws AmazonClientException, AmazonServiceException {
	LOGGER.info("createDirectory invoked, bucketName: {}, dirName: {} and isPublicAccessible: {}", bucketName, dirName, isPublicAccessible);
	final ObjectMetadata metadata = new ObjectMetadata();
	metadata.setContentLength(0);
	// Create empty content,since creating empty folder needs an empty content
	final InputStream emptyContent = new ByteArrayInputStream(new byte[0]);
	// Create a PutObjectRequest passing the directory name suffixed by '/'
	final PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, dirName + AWSUtilConstants.SEPARATOR,
			emptyContent, metadata);
	if(isPublicAccessible){
	  putObjectRequest.setCannedAcl(CannedAccessControlList.PublicRead);
	}
	return s3client.putObject(putObjectRequest);
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
public static void uploadToS3(TransferManager transferManager, final File file, final FileProgressListener fileProgressListener) throws InterruptedException {
    PutObjectRequest putObjectRequest = new PutObjectRequest("car-classifieds", file.getName(), file)
            .withCannedAcl(CannedAccessControlList.PublicRead);
    final Upload upload = transferManager.upload(putObjectRequest);
    upload.addProgressListener(new ProgressListener() {
        @Override
        public void progressChanged(ProgressEvent progressEvent) {
            fileProgressListener.onProgressChanged(progressEvent.getBytesTransferred());
            if (progressEvent.getEventCode() == ProgressEvent.COMPLETED_EVENT_CODE) {
                fileProgressListener.onCompleteUpload();
            }
            if (progressEvent.getEventCode() == com.amazonaws.event.ProgressEvent.STARTED_EVENT_CODE) {
                fileProgressListener.onStartUpload();
            }
            if (progressEvent.getEventCode() == com.amazonaws.event.ProgressEvent.FAILED_EVENT_CODE) {
                fileProgressListener.onFailedUpload();
            }
        }
    });
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
public cfData execute( cfSession _session, cfArgStructData argStruct ) throws cfmRunTimeException{
	
AmazonKey amazonKey	= getAmazonKey(_session, argStruct);
AmazonS3 s3Client		= getAmazonS3(amazonKey);

	String bucket			= getNamedStringParam(argStruct, "bucket", null );
	String key				= getNamedStringParam(argStruct, "key", null );
	
if ( key != null && key.charAt( 0 ) == '/' )
	key	= key.substring(1);

	CannedAccessControlList	acl	= amazonKey.getAmazonCannedAcl( getNamedStringParam(argStruct, "acl", null ) );
	
try {
		s3Client.setObjectAcl(bucket, key, acl);
} catch (Exception e) {
	throwException(_session, "AmazonS3: " + e.getMessage() );
}
return cfBooleanData.TRUE;
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
public cfData execute( cfSession _session, cfArgStructData argStruct ) throws cfmRunTimeException{
	
AmazonKey amazonKey	= getAmazonKey(_session, argStruct);
AmazonS3 s3Client		= getAmazonS3(amazonKey);
	String bucket				= getNamedStringParam(argStruct, "bucket", null );
	
	CannedAccessControlList	acl	= amazonKey.getAmazonCannedAcl( getNamedStringParam(argStruct, "acl", null ) );
	
try {
		s3Client.setBucketAcl(bucket, acl);
} catch (Exception e) {
	throwException(_session, "AmazonS3: " + e.getMessage() );
}

return cfBooleanData.TRUE;
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
/**
 * private | public-read | public-read-write | authenticated-read | bucket-owner-read | bucket-owner-full-control | log-delivery-write
 *
 * @param acl
 * @return
 */
public CannedAccessControlList getAmazonCannedAcl(String acl) {
	if (acl.equalsIgnoreCase("private"))
		return CannedAccessControlList.Private;
	else if (acl.equalsIgnoreCase("public-read") || acl.equalsIgnoreCase("publicread"))
		return CannedAccessControlList.PublicRead;
	else if (acl.equalsIgnoreCase("public-read-write") || acl.equalsIgnoreCase("publicreadwrite"))
		return CannedAccessControlList.PublicReadWrite;
	else if (acl.equalsIgnoreCase("authenticated-read") || acl.equalsIgnoreCase("authenticatedread"))
		return CannedAccessControlList.AuthenticatedRead;
	else if (acl.equalsIgnoreCase("bucket-owner-read") || acl.equalsIgnoreCase("bucketownerread"))
		return CannedAccessControlList.BucketOwnerRead;
	else if (acl.equalsIgnoreCase("bucket-owner-full-control") || acl.equalsIgnoreCase("bucketownerfullcontrol"))
		return CannedAccessControlList.BucketOwnerFullControl;
	else if (acl.equalsIgnoreCase("log-delivery-write") || acl.equalsIgnoreCase("logdeliverywrite"))
		return CannedAccessControlList.LogDeliveryWrite;
	else
		return CannedAccessControlList.Private;
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
@Test
public void testHttpClient() throws Exception {
    String blobName = "blob-name";
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(BYTE_SOURCE.size());
    client.putObject(containerName, blobName, BYTE_SOURCE.openStream(),
            metadata);

    if (Quirks.NO_BLOB_ACCESS_CONTROL.contains(blobStoreType)) {
        client.setBucketAcl(containerName,
                CannedAccessControlList.PublicRead);
    } else {
        client.setObjectAcl(containerName, blobName,
                CannedAccessControlList.PublicRead);
    }

    HttpClient httpClient = context.utils().http();
    URI uri = new URI(s3Endpoint.getScheme(), s3Endpoint.getUserInfo(),
            s3Endpoint.getHost(), s3Proxy.getSecurePort(),
            servicePath + "/" + containerName + "/" + blobName,
            /*query=*/ null, /*fragment=*/ null);
    try (InputStream actual = httpClient.get(uri);
         InputStream expected = BYTE_SOURCE.openStream()) {
        assertThat(actual).hasContentEqualTo(expected);
    }
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
@Override
public boolean publicEntity(String bucketName, String keyName) {
    LOG.info("Sets the CannedAccessControlList for the specified object "
            + keyName
            + " in Amazon S3 using one of the pre-configured CannedAccessControlLists");
    
    try {
    	amazonS3Client.setObjectAcl(bucketName, keyName, CannedAccessControlList.PublicRead);
    	return true;
    } catch (AmazonServiceException ase) {
        LOG.warn(ase.getMessage(), ase);
    } catch (AmazonClientException ace) {
        LOG.warn(ace.getMessage(), ace);
    }
    return false;
}
 

import com.amazonaws.services.s3.model.CannedAccessControlList; //導入依賴的package包/類
private boolean uploadTextAsFile(String key, String contents){
	try{
		byte[] bytes = contents.getBytes("UTF-8");
		InputStream is = new ByteArrayInputStream(bytes);

		String bucket = "s3.staticvoidgames.com";


		ObjectMetadata meta = new ObjectMetadata();
		meta.setContentLength(bytes.length);
		meta.setContentType("text/html");

		String awsAccessKey = env.getProperty("aws.accessKey");
		String awsSecretKey = env.getProperty("aws.secretKey");
		AmazonS3 s3 = new AmazonS3Client(new BasicAWSCredentials(awsAccessKey, awsSecretKey));

		s3.putObject(bucket, key, is, meta);
		s3.setObjectAcl(bucket, key, CannedAccessControlList.PublicRead);
	}
	catch(UnsupportedEncodingException e){
		e.printStackTrace();
		return false;
	}

	return true;
}