scala-news-reader

AmazonS3.scala

(5489B)

 package com.joereader.lib.aws
 
 import java.net.URLEncoder._
 import java.lang.Long
 import com.ning.http.client.RequestBuilder
 import com.ning.http.util.Base64
 import dispatch._
 
 
 protected object AmazonS3 {
 
   import javax.crypto
 
   import java.util.{Date, Locale, SimpleTimeZone}
   import java.text.SimpleDateFormat
 
   val UTF_8 = "UTF-8"
 
   val Root = "s3.amazonaws.com"
 
   object rfc822DateParser extends SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US) {
     this.setTimeZone(new SimpleTimeZone(0, "GMT"))
   }
 
   def trim(s: String): String = s.dropWhile(_ == ' ').reverse.dropWhile(_ == ' ').reverse.toString
 
   def md5(bytes: Array[Byte]) = {
     import java.security.MessageDigest
 
     val r = MessageDigest.getInstance("MD5")
     r.reset()
     r.update(bytes)
     Base64.encode(r.digest)
   }
 
   def md5(stream: java.io.InputStream) = {
     import java.security.MessageDigest
 
     val buffer = new Array[Byte](1024)
     val r = MessageDigest.getInstance("MD5")
     var numRead: Int = 0
     do {
       numRead = stream.read(buffer)
       if (numRead > 0) {
         r.update(buffer, 0, numRead)
       }
     } while (numRead != -1)
 
     stream.close()
     Base64.encode(r.digest())
   }
 
   def sign(method: String, path: String, secretKey: String, date: Date,
            contentType: Option[String], contentMd5: Option[String], amzHeaders: Map[String, Set[String]]): String = {
     sign(method, path, secretKey, Left(date), contentType, contentMd5, amzHeaders)
   }
 
   def sign(method: String, path: String, secretKey: String, dateOrExpires: Either[Date, Long],
            contentType: Option[String], contentMd5: Option[String], amzHeaders: Map[String, Set[String]]) = {
     val SHA1 = "HmacSHA1"
     val message = canonicalString(method, path, dateOrExpires, contentType, contentMd5, amzHeaders)
     val sig = {
       val mac = crypto.Mac.getInstance(SHA1)
       val key = new crypto.spec.SecretKeySpec(bytes(secretKey), SHA1)
       mac.init(key)
       Base64.encode(mac.doFinal(bytes(message)))
     }
     sig
   }
 
   def signedUri(accessKey: String, secretKey: String, method: String, path: String, amzHeaders: Map[String, Set[String]],
                 expires: Long = defaultExpiryTime,
                 contentType: Option[String] = None, contentMd5: Option[String] = None) = {
     val signed = encode(sign(method, path, secretKey, Right(expires), contentType, contentMd5, amzHeaders), "UTF-8")
     "%s?Signature=%s&Expires=%s&AWSAccessKeyId=%s".format(path, signed, expires, accessKey)
   }
 
   def defaultExpiryTime = System.currentTimeMillis() / 1000 + 600
 
   /**
    * @return the canonical request string that needs to be signed for authentication
    */
   def canonicalString(method: String, path: String, dateOrExpires: Either[Date, Long], contentType: Option[String],
                       contentMd5: Option[String], amzHeaders: Map[String, Set[String]]) = {
     val amzString = amzHeaders.toList.sortWith(_._1.toLowerCase < _._1.toLowerCase).map {
       case (k, v) => "%s:%s".format(k.toLowerCase, v.map(trim).mkString(","))
     }
     val dateExpiresString = dateOrExpires match {
       case Left(date) => rfc822DateParser.format(date)
       case Right(expires) => expires.toString
     }
     (method :: contentMd5.getOrElse("") :: contentType.getOrElse("") :: dateExpiresString :: Nil) ++ amzString ++ List(path) mkString "\n"
   }
 
   def bytes(s: String) = s.getBytes(UTF_8)
 
   implicit def Request2S3RequestSigner(r: RequestBuilder) = new S3RequestSigner(r)
 
   implicit def Request2S3RequestSigner(r: String) = new S3RequestSigner(new RequestBuilder().setUrl(r))
 
   class S3RequestSigner(r: RequestBuilder) {
 
     import scala.collection.JavaConverters._
 
     protected def path = RawUri(r.build.getUrl).path.getOrElse("")
 
     def <@(accessKey: String, secretKey: String) = {
       val req = r.build
       val contentStream = req.getStreamData
       val contentMd5 = if (req.getContentLength <= 0) None else Some(md5(contentStream))
 
       for (cmd5 <- contentMd5)
         r.addHeader("Content-MD5", cmd5)
 
       val headers = req.getHeaders
       val contentType = headers.keySet.asScala.find {
         _.toLowerCase == "content-type"
       }.map {
         headers.get(_).asScala.head
       }
 
       val d = new Date
       r.addHeader("Authorization", "AWS %s:%s".format(accessKey, sign(req.getMethod, path, secretKey, d, contentType, contentMd5, amazonHeaders)))
       r.addHeader("Date", AmazonS3.rfc822DateParser.format(d))
       r
     }
 
     def signed(accessKey: String, secretKey: String, expires: Long = defaultExpiryTime,
                contentType: Option[String] = None, contentMd5: Option[String] = None): RequestBuilder = {
       val req = r.build
       val path = RawUri(req.getUrl).path.getOrElse("")
       val uri = signedUri(accessKey, secretKey, req.getMethod, path, amazonHeaders, expires, contentType, contentMd5)
       val requestHeaders = for {
         (key, Some(value)) <- Map("Content-Type" -> contentType, "Content-Md5" -> contentMd5)
       } yield key -> value
       (:/(AmazonS3.Root) / uri.substring(1)).setMethod(req.getMethod).setHeaders(req.getHeaders).secure <:< requestHeaders
     }
 
     private def amazonHeaders = {
       val headers = r.build.getHeaders
       headers.keySet.asScala.filter {
         _.toLowerCase.startsWith("x-amz")
       }
         .map(name => name -> headers.get(name).asScala.toSet).toMap
     }
   }
 
 }
 
 object Bucket extends (String => RequestBuilder) {
   def apply(name: String) = :/(AmazonS3.Root) / name
 }