sndacs 0.0.1 → 0.1.0

data/lib/sndacs/object.rb

@@ -1,6 +1,6 @@
 module Sndacs
 
-  # Class responsible for handling objects stored in S3 buckets
+  # Class responsible for handling objects stored in CS buckets
   class Object
     include Parser
     extend Forwardable
@@ -10,7 +10,7 @@ module Sndacs
     attr_writer :content
 
     def_instance_delegators :bucket, :name, :service, :bucket_request, :vhost?, :host, :path_prefix
-    def_instance_delegators :service, :protocol, :port, :secret_access_key
+    def_instance_delegators :service, :protocol, :port, :access_key_id, :secret_access_key
     private_class_method :new
 
     # Compares the object with other object. Returns true if the key
@@ -57,30 +57,24 @@ module Sndacs
     # to do it).
     def retrieve
       object_headers
-      self
-    end
 
-    # Retrieves the object from the server, returns true if the object
-    # exists or false otherwise. Uses #retrieve method, but catches
-    # S3::Error::NoSuchKey exception and returns false when it happens
-    def exists?
-      retrieve
-      true
-    rescue Error::NoSuchKey
-      false
+      self
     end
 
     # Downloads the content of the object, and caches it. Pass true to
     # clear the cache and download the object again.
     def content(reload = false)
       return @content if defined?(@content) and not reload
+
       get_object
+
       @content
     end
 
     # Saves the object, returns true if successfull.
     def save
       put_object
+
       true
     end
 
@@ -89,7 +83,7 @@ module Sndacs
     # ==== Options
     # * <tt>:key</tt> - New key to store object in
     # * <tt>:bucket</tt> - New bucket to store object in (instance of
-    #   S3::Bucket)
+    #   Sndacs::Bucket)
     # * <tt>:acl</tt> - ACL of the copied object (default:
     #   "public-read")
     # * <tt>:content_type</tt> - Content type of the copied object
@@ -101,40 +95,53 @@ module Sndacs
     # Destroys the file on the server
     def destroy
       delete_object
+
       true
     end
 
     # Returns Object's URL using protocol specified in service,
-    # e.g. <tt>http://domain.com.s3.amazonaws.com/key/with/path.extension</tt>
+    # e.g. <tt>http://storage.grandcloud.cn/bucket/key/file.extension</tt>
     def url
       URI.escape("#{protocol}#{host}/#{path_prefix}#{key}")
     end
 
+    # Returns Object's CNAME URL (without <tt>storage.grandcloud.cn</tt>
+    # suffix) using protocol specified in Service,
+    # e.g. <tt>http://domain.com/key/with/path.extension</tt>. (you
+    # have to set the CNAME in your DNS before using the CNAME URL
+    # schema).
+    def cname_url
+      URI.escape("#{protocol}#{name}/#{key}") if bucket.vhost?
+    end
+
     # Returns a temporary url to the object that expires on the
-    # timestamp given. Defaults to one hour expire time.
+    # timestamp given. Defaults to 5min expire time.
     def temporary_url(expires_at = Time.now + 3600)
+      url = URI.escape("#{protocol}#{host(true)}/#{path_prefix}#{key}")
       signature = Signature.generate_temporary_url_signature(:bucket => name,
                                                              :resource => key,
                                                              :expires_at => expires_at,
                                                              :secret_access_key => secret_access_key)
 
-      "#{url}?AWSAccessKeyId=#{self.bucket.service.access_key_id}&Expires=#{expires_at.to_i.to_s}&Signature=#{signature}"
+      "#{url}?SNDAAccessKeyId=#{access_key_id}&Expires=#{expires_at.to_i.to_s}&Signature=#{signature}"
     end
 
-    # Returns Object's CNAME URL (without <tt>s3.amazonaws.com</tt>
-    # suffix) using protocol specified in Service,
-    # e.g. <tt>http://domain.com/key/with/path.extension</tt>. (you
-    # have to set the CNAME in your DNS before using the CNAME URL
-    # schema).
-    def cname_url
-      URI.escape("#{protocol}#{name}/#{key}") if bucket.vhost?
+    # Retrieves the object from the server, returns true if the object
+    # exists or false otherwise. Uses #retrieve method, but catches
+    # Sndacs::Error::NoSuchKey exception and returns false when it happens
+    def exists?
+      retrieve
+
+      true
+    rescue Error::NoSuchKey
+      false
     end
 
     def inspect #:nodoc:
       "#<#{self.class}:/#{name}/#{key}>"
     end
 
-    private
+  private
 
     attr_writer :last_modified, :etag, :size, :original_key, :bucket
 
@@ -171,11 +178,13 @@ module Sndacs
 
     def get_object(options = {})
       response = object_request(:get, options)
+
       parse_headers(response)
     end
 
     def object_headers(options = {})
       response = object_request(:head, options)
+
       parse_headers(response)
     rescue Error::ResponseError => e
       if e.response.code.to_i == 404
@@ -187,6 +196,7 @@ module Sndacs
 
     def put_object
       response = object_request(:put, :body => content, :headers => dump_headers)
+
       parse_headers(response)
     end
 
@@ -250,4 +260,5 @@ module Sndacs
       end
     end
   end
+
 end

data/lib/sndacs/objects_extension.rb

@@ -1,4 +1,5 @@
 module Sndacs
+
   module ObjectsExtension
     # Builds the object in the bucket with given key
     def build(key)
@@ -34,4 +35,5 @@ module Sndacs
       proxy_target.each { |object| object.destroy }
     end
   end
+
 end

data/lib/sndacs/parser.rb

@@ -1,25 +1,36 @@
 require 'rexml/document'
 
 module Sndacs
+
   module Parser
     include REXML
 
     def rexml_document(xml)
       xml.force_encoding(::Encoding::UTF_8) if xml.respond_to? :force_encoding
+
       Document.new(xml)
     end
 
-    def parse_list_all_my_buckets_result(xml)
-      names = []
-      rexml_document(xml).elements.each("ListAllMyBucketsResult/Buckets/Bucket/Name") { |e| names << e.text }
-      names
-    end
+    def parse_all_buckets_result(xml)
+      all_buckets = []
+      rexml_document(xml).elements.each("ListAllMyBucketsResult/Buckets/Bucket") do |e|
+        bucket_attributes = {}
+        bucket_attributes[:name] = e.elements["Name"].text
 
-    def parse_location_constraint(xml)
-      rexml_document(xml).elements["LocationConstraint"].text
+        element_location = e.elements["Location"]
+        if element_location
+          bucket_attributes[:location] = element_location.text
+        else
+          bucket_attributes[:location] = REGION_DEFAULT
+        end
+
+        all_buckets << bucket_attributes
+      end
+
+      all_buckets
     end
 
-    def parse_list_bucket_result(xml)
+    def parse_all_objects_result(xml)
       objects_attributes = []
       rexml_document(xml).elements.each("ListBucketResult/Contents") do |e|
         object_attributes = {}
@@ -27,11 +38,22 @@ module Sndacs
         object_attributes[:etag] = e.elements["ETag"].text
         object_attributes[:last_modified] = e.elements["LastModified"].text
         object_attributes[:size] = e.elements["Size"].text
+
         objects_attributes << object_attributes
       end
+
       objects_attributes
     end
 
+    def parse_location_constraint(xml)
+      location = rexml_document(xml).elements["LocationConstraint"].text
+      if location.nil? || location == ''
+        location = REGION_DEFAULT
+      end
+
+      location
+    end
+
     def parse_copy_object_result(xml)
       object_attributes = {}
       document = rexml_document(xml)
@@ -51,4 +73,5 @@ module Sndacs
       rexml_document(xml).elements["ListBucketResult/IsTruncated"].text =='true'
     end
   end
+
 end

data/lib/sndacs/request.rb

@@ -1,25 +1,31 @@
 module Sndacs
+
   # Class responsible for sending chunked requests
   # properly. Net::HTTPGenericRequest has hardcoded chunk_size, so we
   # inherit the class and override chunk_size.
   class Request < Net::HTTPGenericRequest
     def initialize(chunk_size, m, reqbody, resbody, path, initheader = nil)
       @chunk_size = chunk_size
+
       super(m, reqbody, resbody, path, initheader)
     end
 
-    private
+  private
 
     def send_request_with_body_stream(sock, ver, path, f)
       unless content_length() or chunked?
         raise ArgumentError, "Content-Length not given and Transfer-Encoding is not `chunked'"
       end
+
       supply_default_content_type
+
       write_header sock, ver, path
+
       if chunked?
         while s = f.read(@chunk_size)
           sock.write(sprintf("%x\r\n", s.length) << s << "\r\n")
         end
+
         sock.write "0\r\n\r\n"
       else
         while s = f.read(@chunk_size)
@@ -28,4 +34,5 @@ module Sndacs
       end
     end
   end
+
 end

data/lib/sndacs/service.rb

@@ -3,15 +3,16 @@ require 'net/http'
 require 'proxies'
 
 require 'sndacs/parser'
-require 'sndacs/buckets_extension'
 require 'sndacs/connection'
+require 'sndacs/buckets_extension'
 
 module Sndacs
+
   class Service
     include Parser
     include Proxies
 
-    attr_reader :access_key_id, :secret_access_key, :use_ssl, :proxy
+    attr_reader :access_key_id, :secret_access_key, :proxy , :use_ssl
 
     # Compares service to other, by <tt>access_key_id</tt> and
     # <tt>secret_access_key</tt>
@@ -30,28 +31,28 @@ module Sndacs
     #   (false by default)
     # * <tt>:timeout</tt> - Timeout to use by the Net::HTTP object
     #   (60 by default)
-    def initialize(options)
-      @access_key_id = options.fetch(:access_key_id)
-      @secret_access_key = options.fetch(:secret_access_key)
-      @use_ssl = options.fetch(:use_ssl, false)
-      @timeout = options.fetch(:timeout, 60)
-      @debug = options.fetch(:debug, false)
-
-      raise ArgumentError, "Missing proxy settings. Must specify at least :host." if options[:proxy] && !options[:proxy][:host]
-      @proxy = options.fetch(:proxy, nil)
+    def initialize(options = {})
+      @access_key_id = options.fetch(:access_key_id, Config.access_key_id)
+      @secret_access_key = options.fetch(:secret_access_key, Config.secret_access_key)
+      @proxy = options.fetch(:proxy, Config.proxy)
+      @timeout = options.fetch(:timeout, Config.timeout)
+      @use_ssl = options.fetch(:use_ssl, Config.use_ssl)
+      @debug = options.fetch(:debug, Config.debug)
+
+      raise ArgumentError, "Wrong proxy settings. Must specify at least :host option." if @proxy && !@proxy[:host]
     end
 
     # Returns all buckets in the service and caches the result (see
     # +reload+)
     def buckets
-      Proxy.new(lambda { list_all_my_buckets }, :owner => self, :extend => BucketsExtension)
+      Proxy.new(lambda { buckets_all }, :owner => self, :extend => BucketsExtension)
     end
 
-    # Returns the bucket with the given name. Does not check whether the
+    # Returns the bucket with the given name and region. Does not check whether the
     # bucket exists. But also does not issue any HTTP requests, so it's
     # much faster than buckets.find
-    def bucket(name)
-      Bucket.send(:new, self, name)
+    def bucket(name, region = nil)
+      Bucket.send(:new, self, name, region || REGION_DEFAULT)
     end
 
     # Returns "http://" or "https://", depends on <tt>:use_ssl</tt>
@@ -70,26 +71,36 @@ module Sndacs
       "#<#{self.class}:#@access_key_id>"
     end
 
-    private
+  private
 
-    def list_all_my_buckets
+    def buckets_all
       response = service_request(:get)
-      names = parse_list_all_my_buckets_result(response.body)
-      names.map { |name| Bucket.send(:new, self, name) }
+
+      all_buckets = parse_all_buckets_result(response.body)
+      all_buckets.map { |bucket| Bucket.send(:new, self, bucket[:name], bucket[:region]) }
     end
 
     def service_request(method, options = {})
-      connection.request(method, options.merge(:path => "/#{options[:path]}"))
+      unless options[:path]
+        options[:path] = '/'
+      end
+
+      req_path = options[:path]
+      if req_path[0,1] != '/'
+        req_path = "/#{req_path}"
+      end
+
+      connection.request(method, options.merge(:path => req_path))
     end
 
     def connection
-      return @connection if defined?(@connection)
-      @connection = Connection.new(:access_key_id => @access_key_id,
-                               :secret_access_key => @secret_access_key,
-                               :use_ssl => @use_ssl,
-                               :timeout => @timeout,
-                               :debug => @debug,
-                               :proxy => @proxy)
+      @connection ||= Connection.new(:access_key_id => @access_key_id,
+                                     :secret_access_key => @secret_access_key,
+                                     :use_ssl => @use_ssl,
+                                     :timeout => @timeout,
+                                     :proxy => @proxy,
+                                     :debug => @debug)
     end
   end
+
 end

data/lib/sndacs/signature.rb

@@ -2,11 +2,11 @@ module Sndacs
 
   # Class responsible for generating signatures to requests.
   #
-  # Implements algorithm defined by Amazon Web Services to sign
+  # Implements algorithm defined by GrandCloud Web Services to sign
   # request with secret private credentials
   #
   # === See
-  # http://docs.amazonwebservices.com/AmazonS3/latest/index.html?RESTAuthentication.html
+  # https://cs-console.grandcloud.cn/public/docs/GrandCloud_Storage_Developer_Guide.pdf
 
   class Signature
 
@@ -62,34 +62,7 @@ module Sndacs
       CGI.escape(signature)
     end
 
-    # Generates temporary URL for given resource
-    #
-    # ==== Options
-    # * <tt>:bucket</tt> - Bucket in which the resource resides
-    # * <tt>:resource</tt> - Path to the resouce you want to create
-    #   a temporary link to
-    # * <tt>:access_key</tt> - Access key
-    # * <tt>:secret_access_key</tt> - Secret access key
-    # * <tt>:expires_at</tt> - Unix time stamp of when the resouce
-    #   link will expire
-    # * <tt>:method</tt> - HTTP request method you want to use on
-    #   the resource, defaults to GET
-    # * <tt>:headers</tt> - Any additional HTTP headers you intend
-    #   to use when requesting the resource
-    def self.generate_temporary_url(options)
-      bucket = options[:bucket]
-      resource = options[:resource]
-      access_key = options[:access_key]
-      expires = options[:expires_at].to_i
-      signature = generate_temporary_url_signature(options)
-
-      url = "http://#{S3::HOST}/#{bucket}/#{resource}"
-      url << "?AWSAccessKeyId=#{access_key}"
-      url << "&Expires=#{expires}"
-      url << "&Signature=#{signature}"
-    end
-
-    private
+  private
 
     def self.canonicalized_signature(options)
       headers = options[:headers] || {}
@@ -120,6 +93,7 @@ module Sndacs
       digest = OpenSSL::Digest::Digest.new("sha1")
       hmac = OpenSSL::HMAC.digest(digest, secret_access_key, string_to_sign)
       base64 = Base64.encode64(hmac)
+
       base64.chomp
     end
 
@@ -209,7 +183,7 @@ module Sndacs
       # requests that don't address a bucket, do nothing. For more
       # information on virtual hosted-style requests, see Virtual
       # Hosting of Buckets.
-      bucket_name = host.sub(/\.?storage\.grandcloud\.cn\Z/, "")
+      bucket_name = host.sub(/\.?storage[a-zA-Z0-9\-]*?\.grandcloud\.cn\Z/, "")
       string << "/#{bucket_name}" unless bucket_name.empty?
 
       # 3. Append the path part of the un-decoded HTTP Request-URI,
@@ -240,4 +214,5 @@ module Sndacs
       string
     end
   end
+
 end

data/lib/sndacs/version.rb

@@ -1,3 +1,3 @@
 module Sndacs
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/sndacs.rb

@@ -1,3 +1,6 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
 require "base64"
 require "cgi"
 require "digest/md5"
@@ -13,6 +16,7 @@ require "sndacs/objects_extension"
 require "sndacs/buckets_extension"
 require "sndacs/parser"
 require "sndacs/bucket"
+require "sndacs/config"
 require "sndacs/connection"
 require "sndacs/exceptions"
 require "sndacs/object"
@@ -22,6 +26,28 @@ require "sndacs/signature"
 require "sndacs/version"
 
 module Sndacs
-  # Default (and only) host serving S3 stuff
-  HOST = "storage.grandcloud.cn"
+
+  # Bucket default region
+  # NOTICE: DO NOT TOUCH THIS!!!
+  REGION_DEFAULT = 'huadong-1'
+
+  # Bucket region host template
+  # NOTICE: DO NOT TOUCH THIS!!!
+  REGION_HOST = 'storage-%s.grandcloud.cn'
+
+  # Object public access host template
+  # NOTICE: DO NOT TOUCH THIS!!!
+  REGION_CONTENT_HOST = 'storage-%s.sdcloud.cn'
+
+  # Default configurations, see Sndacs::Config for more info
+  #Config.access_key_id = ''
+  #Config.secret_access_key = ''
+  #Config.host = 'storage.grandcloud.cn'
+  #Config.content_host = 'storage.sdcloud.cn'
+  #Config.proxy = nil
+  #Config.timeout = 60
+  #Config.use_ssl = false
+  #Config.chunk_size = 1048576
+  #Config.debug = false
+
 end

data/sndacs.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
-# Load version requiring the canonical "s3/version", otherwise Ruby will think
-# is a different file and complaint about a double declaration of S3::VERSION.
+# Load version requiring the canonical "sndacs/version", otherwise Ruby will think
+# is a different file and complaint about a double declaration of Sndacs::VERSION.
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "sndacs/version"
 
@@ -12,16 +12,16 @@ Gem::Specification.new do |s|
   s.authors     = ["LI Daobing"]
   s.email       = ["lidaobing@snda.com"]
   s.homepage    = "https://github.com/grandcloud/sndacs-ruby"
-  s.summary     = "Library for accessing SNDA Cloud Storage objects and buckets"
+  s.summary     = "Library for accessing SNDA Cloud Storage buckets and objects"
   s.description = "sndacs library provides access to SNDA Cloud Storage."
 
   s.required_rubygems_version = ">= 1.3.6"
 
   s.add_dependency "proxies", "~> 0.2.0"
-  s.add_development_dependency "test-unit", ">= 2.0"
-  s.add_development_dependency "mocha"
   s.add_development_dependency "bundler", ">= 1.0.0"
   s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "mocha"
+  #s.add_development_dependency "test-unit", ">= 2.0"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact