id="${bucketName}"

Note: You could easily add search to your Amazon S3 Bucket Object list by using AmazonS3.listObjects(String bucketName, String prefix).

The BucketController's create action builds the information necessary for Amazon S3 to accept an HTML post. Amazon requires the post to contain, among a few other things, policy and signature parameters. The policy parameter is a JavaScript Object Notation (JSON) string that must be Base64, and the signature needs to be encrypted using your Amazon secret key. The more important values in the policy JSON string to pay particular attention to are:

• bucket. This is the name of the bucket.
• content-length-range. Use this value to limit the upload bytes.
• expiration. This is the time at which this HTTP post request would no longer be valid. This application sets it to a day later, but you might set it to 5 or 10 minutes later for a tighter security measure.
• succes_action_redirect. The request goes to Amazon, not this Web application. Amazon needs the URL of a page to display when the upload is complete.

The succes_action_redirect setting bears extra mention, as well. The Grails grails-app/conf/Config.groovy file has a setting called grails.serverURL. When in development mode, it is set to https://localhost:8080/. But, for production, you will have to set the proper domain and context root in Config.groovy.

The Amazon HTTP Post strategy is described in great detail in Browser Uploads to S3 using HTML POST Forms. But whereas the article provides Ruby, Java, and Python code examples, BucketController's create action gives you a groovier example.

In your grails-app/view/bucketObject directory, delete edit.gsp. Then, replace the entire contents of create.gsp with the following:

  
  
   
  
  
  
  
  
Amazon S3 Bucket: ${params.id}
  Select file to upload:
  

  

Note: If you would like to upload a file to Amazon S3 directly from your application instead of an HTTP post, use the following command:

s3.putObject(new PutObjectRequest('',
         timeFormat.format(new Date()), new File(''))

Bucket objects can contain huge amounts of data, and that data can be in any format. But the browser for Amazon S3 blatantly displays any Amazon S3 object data in a

 tag of show.gsp. So, the browser for Amazon S3 has to provide pagination when showing the contents of a bucket object. Luckily, unlike the BucketObjectController's list action, the show action is able to use standard Grails pagination. Grails uses two HTTP request parameters—max and offset—to control the number of objects to display and keep track of where to start retrieving the next set of objects. With GORM/Java Database Components (JDBC), max stored the count of domain objects to display, and offset stored a row number. But with BucketObjectController's show action, max is the number of bytes to display, and offset is the index of the Amazon S3 bucket objects' byte contents. You certainly don't want to retrieve the complete contents of a 1-GB MySQL backup for display!
				

				
Among the AmazonS3.getObject()'s overloaded methods is one that takes a GetObjectRequest object. GetObjectRequest has a withRange method, which lets you set the byte range to retrieve. Here's the complete code for BucketObjectController's show action:
				

def show = {
  params.max = params.max ? params.int('max') : 10000
  params.offset = params.offset ? params.int('offset'):0

  ObjectMetadata meta = s3.getObjectMetadata(params.bucketName, params.key)
  GetObjectRequest getObjReq = new GetObjectRequest(params.bucketName, params.key)
  getObjReq.withRange(params.offset, params.max+params.offset)

  [text:s3.getObject(getObjReq).objectContent.text,meta:meta.metadata, params:params]
}


				
So, the use of the withRange method is why displaying an Amazon S3 backup of a 1-GB MySQL dump is not a problem.
				
				
In show.gsp, replace the 
  and 
 divisions with the following:
				



  
Bucket: ${params.bucketName} Key: ${params.key}
  
    
${flash.message}
  
  
    

                    
    
  
  

    
${text}
  
  

    
      
      
      
      
    
  



				
Then, to the  and  tags that are inside the 
 near the top of the GSP, add an id attribute setting so that the BucketObjectController's list action knows which bucket name to list or create:
				


id="${params.bucketName}"



		
Odds and Ends
				
Here are a few odds and ends to finish up the browser.

				
Changing the Default Page
						
If the strange Hello World–style default Grails page doesn't show up, edit grails-app/conf/UrlMappings.groovy to replace "/"(view:"/index") with "/"(controller:'bucket',action:"/list"). Now, whenever you go to the root URL or click Home, the bucket list will be displayed.
						

				
The Download Option
						
You may have noticed the download link in the Bucket Object list. That download is implemented with two Groovy statements in a closure called download in BucketObjectControoler:
						

response.contentType = "application/octet-stream"
response.outputStream <<
     s3.getObject(params.bucketName, params.key).objectContent


						
Using the combined magic of Groovy and Grails, the InputStream returned from the AmazonS3Client.getObject() method is left-shifted << into the HTTP output response stream. The browser then prompts the user to open or save the file. Between the upload option (invoked by clicking the New Bucket Object button) or the download links, you have a simple way to back up (and version) important files.
						
						
Note: If you would like to download a file locally, use the following one-liner:
						

new File('').append(s3.getObject('', '').getObjectContent())


				
Deleting Buckets and Bucket Objects
						
Deletion of buckets and bucket objects is enabled with Delete links that point to the delete action of BucketController or BucketObjectController. Those links pass the bucket name and (if the deletion is for a Bucket object) the object's key. The Controller code is trivial. BucketObjectController's delete action simply executes the following:
						

s3.deleteObject(params.bucketName, params.key)


The delete action then puts an informational message in the flash scope and redirects to the list action. Subsequently, the list.gsp page displays the deletion message.

						
BucketController's delete action does pretty much the same thing as BucketObjectController, except that it wraps s3.deleteBucket(params.bucketName) in a try/catch block. I found that I had to add the try/catch to monitor for the Amazon "The bucket you tried to delete is not empty" error. If an error occurs, the delete action stuffs the message in the flash scope and redirects to the list action.


		
Improvements
				
There are a couple of areas where the browser for Amazon S3 application could be improved:
				
						

								
Add error handling. (To keep the code terse, I added error handling only where explicitly required.)
								
								
Add the show and update operations back into the Bucket controller to maintain ACL, logging, and versioning information.
								
								
Add the update operation back into the Bucket Object controller to maintain standard Amazon S3 metadata and custom user metadata.
								
								
Add search facilities to the Bucket Object controller using AmazonS3's listObject's prefix option.
								
								
Add pagination to the bucket list.
						



		
Using the Browser for Amazon S3
				
The browser for Amazon S3 is now ready. You can run it locally by running the Grails embedded server in your shell window:
				

grails run-app


				
Then, test the generated application from your browser from https://localhost:8080.
				
				
Or, you can create a Java 2 Platform, Enterprise Edition (J2EE) Web archive (WAR) file with:
				

grails war


				
and deploy the Amazon S3 browser application to your favorite Java servlet container.
				

				
The Browser for Amazon S3's Bucket List Home Page
						
The Amazon S3 Bucket List displays all the buckets you own. If you click New Bucket, you will be prompted for the name of the bucket you want to create. The browser for Amazon S3 application will add the bucket (or display an error, such as "The bucket already exists") and rebuild the Bucket Object List to show the newly added bucket.
						


				
Create a Bucket Prompt
						
On the home page (the Amazon S3 Bucket List,) if you click one of the Bucket Object links, a paginated list of the objects in that bucket is displayed.
						


				
The Amazon S3 Bucket Object List
						
Click one of the bucket object links to see a paginated list (where each page is 10,000 bytes) of the contents of that object.
						


				
The Amazon S3 Bucket Object Display
						
The Bucket Object page, in addition to pagination buttons, has a New BucketObject button and a Delete button. A click of Delete deletes the object for the Amazon S3 bucket and redisplays the Amazon S3 Bucket Object List. A click of New BucketObject prompts you with the Amazon S3 Bucket Object Create page.
						


				
The Amazon S3 Bucket Object Create Page
						
The Create page's HTTP post goes directly to Amazon, so the page is built with the Amazon S3–required encryption policy and signature variables. When you have selected a file to upload and click Upload, Amazon adds the bucket and redirects your browser to the browser for Amazon S3's Bucket Object List.
						


						
If, on the Amazon S3 Bucket Object List, you click one of the download links, the browser for Amazon S3 application pulls the object from Amazon and passes it to the browser, where you will be prompted to save the file.
						

				
The S3 Bucket Object Download Page
						
The Download page is self-explanatory.



		
Stats and Usage
				
The browser for Amazon S3 application gives you a simple interface with which to manage your Amazon S3 objects. You pay Amazon to store those objects, but without a browser, the number and size of your Amazon S3 objects can easily get out of control. It's also nice to have a simple facility to quickly back up, restore, or transfer files. For example, I've been using the browser for Amazon S3 to save some of the oddball files I have from spread sheets to MySQL dumps.
				
				
What is impressive about Groovy and Grails is that this application contained a mere 127 lines of code (not counting the HTML.) Grails generated the application infrastructure, mananged the REST-based MVC architecture, and provided the simplified user interface of GSP. Groovy made the interface with the AWS SDK for Java trivial.
				
Regardless of whether you use the browser for Amazon S3, a benefit of this article is that it provides a tutorial on the use of the AWS SDK for Java. You now have a kit-bag of 1–3 liners of Groovy code that gives you easy access to maintenance operations on your Amazon S3 objects.