waz-blobs 0.1.0

data/lib/waz/blobs/base.rb

@@ -0,0 +1,22 @@
+module WAZ
+  module Blobs
+    class Base
+      class << self
+        def establish_connection!(options = {})
+          raise InvalidOption.new(:account_name) unless options.keys.include? :account_name
+          raise InvalidOption.new(:access_key) unless options.keys.include? :access_key
+          options[:use_ssl] = false unless options.keys.include? :use_ssl
+          @connection = options
+        end
+        
+        def default_connection
+          return @connection
+        end
+        
+        def connected?
+          return !@connection.nil?
+        end
+      end
+    end
+  end
+end

data/lib/waz/blobs/blob_object.rb

@@ -0,0 +1,46 @@
+module WAZ
+  module Blobs
+    class BlobObject      
+      attr_accessor :name, :url, :content_type
+      
+      def initialize(name, url, content_type)
+        self.name = name
+        self.url = url
+        self.content_type = content_type
+      end
+      
+      def metadata
+        @properties ||= service_instance.get_blob_properties(path)
+      end
+      
+      def value
+        @value ||= service_instance.get_blob(path)
+      end
+      
+      def value=(new_value)
+        service_instance.put_blob(path, new_value, content_type, metadata)
+        @value = new_value
+      end
+      
+      def put_properties(properties = {})
+        service_instance.set_blob_properties(path, properties)
+        @properties = metadata.merge(properties)
+      end
+      
+      def destroy!
+        service_instance.delete_blob(path)
+      end
+      
+      def path
+        url.gsub(/https?:\/\/[^\/]+\//i, '').scan(/([^&]+)/i).first().first()
+      end
+      
+      private
+        def service_instance
+          options = Base.default_connection
+          @service_instance ||= Service.new(options[:account_name], options[:access_key])
+        end
+    end
+  end
+end
+  

data/lib/waz/blobs/container.rb

@@ -0,0 +1,85 @@
+module WAZ
+  module Blobs
+    class Container
+      #Singleton methods 
+      class << self 
+        def create(name)
+          service_instance.create_container(name)
+          return Container.new(name)
+        end
+        
+        def find(name)
+          begin 
+            properties = service_instance.get_container_properties(name)
+            return Container.new(name, properties)
+          rescue RestClient::ResourceNotFound
+            return nil
+          end
+        end
+        
+        private
+          def service_instance
+            options = Base.default_connection
+            return Service.new(options[:account_name], options[:access_key])
+          end        
+      end
+      
+      attr_accessor :name, :properties, :public_access
+      
+      def initialize(name, metadata = nil)
+        self.name = name
+        self.properties = metadata
+      end
+      
+      def metadata
+        self.properties ||= service_instance.get_container_properties(self.name)
+      end
+      
+      def put_properties(properties = {})
+        service_instance.set_container_properties(self.name, properties)
+        self.properties = metadata.merge!(properties)
+      end
+      
+      def destroy!
+        service_instance.delete_container(self.name)
+      end
+      
+      def public_access?
+        public_access ||= service_instance.get_container_acl(self.name)
+      end
+      
+      def public_access=(value)
+        public_access = value
+        service_instance.set_container_acl(self.name, value)
+      end
+      
+      def blobs
+        service_instance.list_blobs(name).map { |blob| WAZ::Blobs::BlobObject.new(blob[:name], blob[:url], blob[:content_type]) }
+      end
+      
+      def store(blob_name, payload, content_type, options = {})
+        service_instance.put_blob("#{self.name}/#{blob_name}", payload, content_type, options)
+        return BlobObject.new(blob_name, 
+                              service_instance.generate_request_uri(nil, "#{self.name}/#{blob_name}"),
+                              content_type)
+      end
+      
+      def [](blob_name)
+        begin
+          properties = service_instance.get_blob_properties("#{self.name}/#{blob_name}")
+          return BlobObject.new(blob_name, 
+                                service_instance.generate_request_uri(nil, "#{self.name}/#{blob_name}"),
+                                properties[:content_type])
+        rescue RestClient::ResourceNotFound
+          return nil
+        end
+      end
+      
+      private
+        def service_instance
+          options = Base.default_connection
+          @service_instance ||= Service.new(options[:account_name], options[:access_key])
+        end
+    end
+  end
+end

data/lib/waz/blobs/exceptions.rb

@@ -0,0 +1,12 @@
+module WAZ
+  module Blobs
+    class WAZStorageException < StandardError
+    end
+    
+    class InvalidOption < WAZStorageException
+      def initialize(missing_option)
+        super("You did not provide both required access keys. Please provide the #{missing_option}.")
+      end
+    end
+  end
+end

data/lib/waz/blobs/service.rb

@@ -0,0 +1,144 @@
+module WAZ
+  module Blobs
+    class Service
+      attr_accessor :account_name, :account_key, :use_ssl, :base_url
+      
+      def initialize(account_name, account_key, use_ssl = false, base_url = "blob.core.windows.net" )
+        self.account_name = account_name
+        self.account_key = account_key 
+        self.use_ssl = use_ssl
+        self.base_url = base_url
+      end
+      
+      def create_container(container_name)
+        url = generate_request_uri(nil, container_name)
+        request = generate_request("PUT", url)
+        request.execute()
+      end
+      
+      def get_container_properties(container_name)
+        url = generate_request_uri(nil, container_name)
+        request = generate_request("GET", url)
+        request.execute().headers
+      end
+      
+      def set_container_properties(container_name, properties = {})
+        url = generate_request_uri("metadata", container_name)
+        request = generate_request("PUT", url, properties)
+        request.execute()
+      end
+      
+      def get_container_acl(container_name)
+        url = generate_request_uri("acl", container_name)
+        request = generate_request("GET", url)
+        request.execute().headers[:x_ms_prop_publicaccess].downcase == true.to_s
+      end
+
+      def set_container_acl(container_name, public_available = false)
+        url = generate_request_uri("acl", container_name)
+        request = generate_request("PUT", url, "x-ms-prop-publicaccess" => public_available.to_s)
+        request.execute()
+      end
+
+      def list_containers(options = {})
+        url = generate_request_uri("list", nil, options)
+        request = generate_request("GET", url)
+        doc = REXML::Document.new(request.execute())
+        containers = []
+        REXML::XPath.each(doc, '//Container/') do |item|
+          containers << { :name => REXML::XPath.first(item, "Name").text,
+                          :url => REXML::XPath.first(item, "Url").text,
+                          :last_modified => REXML::XPath.first(item, "LastModified").text}
+        end
+        return containers
+      end
+
+      def delete_container(container_name)
+        url = generate_request_uri(nil, container_name)
+        request = generate_request("DELETE", url)
+        request.execute()
+      end
+
+      def list_blobs(container_name)
+        url = generate_request_uri("list", container_name)
+        request = generate_request("GET", url)
+        doc = REXML::Document.new(request.execute())
+        containers = []
+        REXML::XPath.each(doc, '//Blob/') do |item|
+          containers << { :name => REXML::XPath.first(item, "Name").text,
+                          :url => REXML::XPath.first(item, "Url").text,
+                          :content_type =>  REXML::XPath.first(item, "ContentType").text }
+        end
+        return containers
+      end
+
+      def put_blob(path, payload, content_type = "application/octet-stream", metadata = {})
+        url = generate_request_uri(nil, path)
+        request = generate_request("PUT", url, metadata.merge("Content-Type" => content_type), payload)
+        request.execute()
+      end
+          
+      def get_blob(path)
+        url = generate_request_uri(nil, path)
+        request = generate_request("GET", url)
+        request.execute()
+      end
+
+      def delete_blob(path)
+        url = generate_request_uri(nil, path)
+        request = generate_request("DELETE", url)
+        request.execute()
+      end
+            
+      def get_blob_properties(path)
+        url = generate_request_uri(nil, path)
+        request = generate_request("HEAD", url)
+        request.execute().headers
+      end
+
+      def set_blob_properties(path, properties ={})
+        url = generate_request_uri("metadata", path)
+        request = generate_request("PUT", url, properties)
+        request.execute()
+      end
+      
+      def generate_request(verb, url, headers = {}, payload = nil)
+        http_headers = {}
+        headers.each{ |k, v| http_headers[k.to_s.gsub(/_/, '-')] = v}
+        request = RestClient::Request.new(:method => verb.downcase.to_sym, :url => url, :headers => http_headers, :payload => payload)
+        request.headers["x-ms-Date"] = Time.new.httpdate
+        request.headers["Content-Length"] = (request.payload or "").length
+        request.headers["Authorization"] = "SharedKey #{account_name}:#{generate_signature(request)}"
+        return request
+      end
+            
+      def generate_request_uri(operation = nil, path = nil, options = {})
+        protocol = use_ssl ? "https" : "http"
+        query_params = options.keys.sort{ |a, b| a.to_s <=> b.to_s}.map{ |k| "#{k.to_s.gsub(/_/, '')}=#{options[k]}"}.join("&") unless options.empty?
+        uri = "#{protocol}://#{account_name}.#{base_url}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}#{operation ? "?comp=" + operation : ""}"
+        uri << "#{operation ? "&" : "?"}#{query_params}" if query_params
+        return uri
+      end
+      
+      def self.canonicalize_headers(headers)
+        cannonicalized_headers = headers.keys.select {|h| h.to_s.start_with? 'x-ms'}.map{ |h| "#{h.downcase.strip}:#{headers[h].strip}" }.sort{ |a, b| a <=> b }.join("\x0A")
+        return cannonicalized_headers
+      end
+      
+      def canonicalize_message(url)
+        uri_component = url.gsub(/https?:\/\/[^\/]+\//i, '').scan(/([^&]+)/i).first()
+        cannonicalized_message = "/#{self.account_name}/#{uri_component}"
+      end
+      
+      def generate_signature(request)
+         signature = request.method.to_s.upcase + "\x0A" +
+                     (request.headers["Content-MD5"] or "") + "\x0A" +
+                     (request.headers["Content-Type"] or "") + "\x0A" +
+                     (request.headers["Date"] or "")+ "\x0A" +
+                     self.class.canonicalize_headers(request.headers) + "\x0A" +
+                     canonicalize_message(request.url)
+         return Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.account_key)).update(signature.toutf8).digest)
+       end
+    end
+  end
+end

data/lib/waz/blobs/version.rb

@@ -0,0 +1,11 @@
+module WAZ
+  module Blobs
+    module VERSION #:nodoc:
+      MAJOR    = '0'
+      MINOR    = '1'
+      TINY     = '0' 
+    end
+    
+    Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'
+  end
+end

data/lib/waz-blobs.rb

@@ -0,0 +1,19 @@
+require 'time'
+require 'cgi'
+require 'base64'
+require 'rexml/document'
+require 'rexml/xpath'
+
+require 'restclient'
+require 'hmac-sha2'
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'waz/blobs/base'
+require 'waz/blobs/blob_object'
+require 'waz/blobs/container'
+require 'waz/blobs/exceptions'
+require 'waz/blobs/service'
+require 'waz/blobs/version'
+
+

data/rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'lib/waz-blobs'
+
+
+namespace :test do
+  Spec::Rake::SpecTask.new('run_with_rcov') do |t|
+    puts "running tests and code coverage"    
+    t.spec_files = FileList['tests/waz/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--text-report', '--exclude', ".gem,test,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
+    t.spec_opts = ['-cfn']
+  end
+end
+
+namespace :dist do  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'waz-blobs'
+    s.version           = Gem::Version.new(WAZ::Blobs::Version)
+    s.summary           = "Client library for Windows Azure's Blob Storage Service's REST API"
+    s.description       = s.summary
+    s.email             = 'johnny.halife@me.com'
+    s.author            = 'Johnny G. Halife'
+    s.homepage          = 'http://github.com/johnnyhalife/waz-blobs'
+    s.require_paths     = ["lib"]
+    s.files             = FileList['rakefile', 'lib/**/*.rb']
+    s.test_files        = Dir['test/**/*']
+    s.has_rdoc          = false
+    
+    # Dependencies
+    s.add_runtime_dependency 'rest-client', '>= 1.0.3'
+    s.add_dependency 'ruby-hmac'
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: waz-blobs
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Johnny G. Halife
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Client library for Windows Azure's Blob Storage Service's REST API
+email: johnny.halife@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- lib/waz/blobs/base.rb
+- lib/waz/blobs/blob_object.rb
+- lib/waz/blobs/container.rb
+- lib/waz/blobs/exceptions.rb
+- lib/waz/blobs/service.rb
+- lib/waz/blobs/version.rb
+- lib/waz-blobs.rb
+has_rdoc: true
+homepage: http://github.com/johnnyhalife/waz-blobs
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Client library for Windows Azure's Blob Storage Service's REST API
+test_files: []
+