Summary

No overview generated for 'S3.js'

//
// Copyright (c) 2006 Tobi Schäfer
// Alle Rechte vorbehalten. All rights reserved.
//
// $Revision$
// $Author$
// $Date$
//

function S3Connection(host) {
   app.addRepository("modules/core/Date.js");
   app.addRepository("modules/core/String.js");
   
   host = host || "s3.amazonaws.com";
   var crypto = Packages.javax.crypto;
   var mac = crypto.Mac.getInstance("HmacSHA1");
   var currentBucket, awsId;

   var doRequest = function(method, param) {
      if (param.length < 1) {
         //throw Error("Missing required argument when executing S3 request");
      }

      // FIXME: Not really a clean way to make a fresh HTTP request each time
      helma.Http.call(this);
      
      this.setMethod(method);
      // Initialize the content type header for safety reasons
      this.setHeader("Content-Type", "");
      this.setHeader("Host", host);
      this.setHeader("Date", (new Date).format(
         "EEE, dd MMM yyyy HH:mm:ss Z", java.util.Locale.US
      ));
 
      var baseUri = "http://" + host;
      var bucket, object;
      
      if (currentBucket) {
         bucket = currentBucket;
         object = param[0]; 
      } else {
         bucket = param[0];
         object = param[1]; 
      }
      
      var path = new java.lang.StringBuffer("/");
      
      if (bucket) {
         if (bucket.constructor == S3Bucket) {
            path.append(bucket.getName());
         } else if (method == "PUT" && !object) {
            throw Error("PUT request requires S3Bucket instance as argument")
         } else {
            path.append(bucket);
         }
      }
      
      if (object) {
         path.append("/");
         if (object.constructor == S3Object) {
            path.append(object.getName());
            if (method == "PUT") {
               var content = object.getContent();
               this.setContent(content);
               this.setHeader("Content-Type", object.getContentType());
               //this.setHeader("Content-MD5", content.md5());
            }
         } else {
            if (method == "PUT") {
               throw Error("PUT request requires S3Object instance as argument");
            }
            path.append(object);
         }
      }
      
      var request = new java.lang.StringBuffer(method + "\n");      
      request.append((this.getHeader("Content-MD5") || "") + "\n");
      request.append((this.getHeader("Content-Type") || "") + "\n");
      request.append(this.getHeader("Date") + "\n");
      if (method == "PUT") {
         (object || bucket).forEachProperty(function(name, value) {
            this.setHeader(name, value);
            request.append(name + ":" + value + "\n");
         });
      }
      request.append(path);
      
      var base64 = new Packages.sun.misc.BASE64Encoder();
      var signature = base64.encode(mac.doFinal(java.lang.String(request).getBytes()));
      var auth = "AWS " + awsId + ":" + signature;
      
      //res.writeln(auth);
      //res.writeln(java.lang.String(request));
      
      this.setHeader("Authorization", auth);
      return this.getUrl((baseUri + path).replace(/([^:])\/\//g, "$1/"));
   };
   
   this.authenticate = function(id, key) {
      var signingKey = new crypto.spec.SecretKeySpec(
         (new java.lang.String(key)).getBytes(), "HmacSHA1"
      );
      mac.init(signingKey);   
      awsId = id;
      return;
   };
   
   this.setCurrentBucket = function(bucket) {
      currentBucket = bucket;
      return;
   };
   
   this.get = function(/* bucket and/or object */) {
      return doRequest("GET", arguments);      
      // The result should be transformed into an S3Bucket or S3Object at this point.
      // Both object types should allow remote manipulation via the S3Connection.
   };
   
   this.put = function(/* bucket and/or object */) {
      return doRequest("PUT", arguments);
   };
   
   this.getInfo = function(/* bucket and/or object */) {
      return doRequest("HEAD", arguments);
   };
   
   this.remove = function(/* bucket and/or object */) {
      return doRequest("DELETE", arguments);
   };
   
   this.close = function() {
      awsId = null;
      mac.init(new crypto.spec.SecretKeySpec([0], "HmacSHA1"));
      return;
   };
   
   this.toString = function() {
      return "[S3Connection" + (awsId ? "" : " (closed)") + "]";
   };
   
   return this;
}

function S3Container(name) {
   var PROPERTYPREFIX = "x-amz-";
   var properties = {};

   if (!name) {
      throw Error("Missing required name argument when instantiating S3 container");
   }
   
   this.getName = function() {
      return name;
   };

   this.getProperty = function(name) {
      return properties[PROPERTYPREFIX + name];
   };
   
   this.forEachProperty = function(callback) {
      var i;
      for (i in properties) {
         callback(i, properties[i]);
      }
      return;
   };
   
   this.setProperty = function(name, value) {
      var key = name.trim().toLowerCase();
      if (!key.startsWith(PROPERTYPREFIX)) {
         key = PROPERTYPREFIX + key;
      }
      properties[key] = value;
      return;
   };
   
   this.setPrivate = function() {
      return this.setProperty("acl", "private");
   };
   
   this.setPublic = function() {
      return this.setProperty("acl", "public-read");
   };

   this.setPublicWritable = function() {
      return this.setProperty("acl", "public-read-write");
   };
   
   this.toString = function() {
      return "[S3Container]";
   };
   
   return this;   
}

function S3Bucket(name, objects) {
   S3Container.call(this, name);
   
   objects = objects || {};
   
   this.getObjects = function() {
      return objects;
   };
   
   this.toString = function() {
      return "[S3Bucket " + name + "]";
   }
   
   return this;
}

function S3Object(name, properties) {
   S3Container.call(this, name);

   var content;
   var contentType = "text/plain";
   properties = properties || {};
   
   this.getContent = function() {
      return content;
   };
   
   this.getContentType = function() {
      return contentType;
   };
   
   this.setContent = function(data) {
      content = data;
      return;
   };
   
   this.setContentType = function(type) {
      contentType = type;
      return;
   };
   
   this.toString = function() {
      return "[S3Object " + name + "]";
   };
   
   return this;
}