raws 0.0.7

data/lib/raws/sdb.rb

@@ -0,0 +1,119 @@
+class RAWS::SDB
+  autoload :Adapter, 'raws/sdb/adapter'
+  autoload :Select,  'raws/sdb/select'
+  autoload :Model,   'raws/sdb/model'
+
+  class << self
+    def create_domain(domain_name)
+      Adapter.create_domain(domain_name)
+    end
+
+    def delete_domain(domain_name)
+      Adapter.delete_domain(domain_name)
+    end
+
+    def metadata(domain_name)
+      Adapter.domain_metadata(
+        domain_name
+      )['DomainMetadataResponse']['DomainMetadataResult']
+    end
+
+    def list(next_token=nil, max_num=nil)
+      Adapter.list_domains(
+        next_token,
+        max_num
+      )['ListDomainsResponse']['ListDomainsResult']
+    end
+
+    def each(&block)
+      next_token = nil
+      begin
+        data = list(next_token)
+        if domain = data['DomainName']
+          domain.each do |val|
+            block.call(self.new(val))
+          end
+        end
+      end while next_token = data['NextToken']
+    end
+
+    def [](domain_name)
+      @cache ||= {}
+      @cache[domain_name] ||= self.new(domain_name)
+    end
+
+    def select(expr, params=[], next_token=nil, &block)
+      begin
+        data = Adapter.select(
+          expr,
+          params,
+          next_token
+        )['SelectResponse']['SelectResult']
+
+        data['Item'].each do |val|
+          block.call([val['Name'], val['Attribute']])
+        end if data.key? 'Item'
+      end while next_token = data['NextToken']
+    end
+    alias :all :select
+
+    def get(domain_name, item_name, *attrs)
+      Adapter.get_attributes(
+        domain_name,
+        item_name,
+        *attrs
+      )['GetAttributesResponse']['GetAttributesResult']['Attribute']
+    end
+
+    def put(domain_name, item_name, attrs={}, *replaces)
+      Adapter.put_attributes(domain_name, item_name, attrs, *replaces)
+    end
+
+    def batch_put(domain_name, items={}, replaces={})
+      Adapter.batch_put_attributes(domain_name, items, replaces)
+    end
+
+    def delete(domain_name, item_name, attrs={})
+      Adapter.delete_attributes(domain_name, item_name, attrs)
+    end
+  end
+
+  attr_reader :domain_name
+
+  def initialize(domain_name)
+    @domain_name = domain_name
+  end
+
+  def create_domain
+    self.class.create_domain(domain_name)
+  end
+
+  def delete_domain
+    self.class.delete_domain(domain_name)
+  end
+
+  def metadata
+    self.class.metadata(domain_name)
+  end
+
+  def select(output_list='*', &block)
+    Select.new.columns(output_list).from(domain_name, &block)
+  end
+  alias :all :select
+
+  def get(item_name, *attrs)
+    self.class.get(domain_name, item_name, *attrs)
+  end
+
+  def put(item_name, attrs={}, *replaces)
+    self.class.put(domain_name, item_name, attrs, *replaces)
+  end
+
+  def batch_put(items={}, replaces={})
+    self.class.batch_put(domain_name, items, replaces)
+  end
+
+  def delete(item_name, attrs={})
+    self.class.delete(domain_name, item_name, attrs)
+  end
+end

data/lib/raws/sqs/adapter.rb

@@ -0,0 +1,148 @@
+class RAWS::SQS::Adapter
+  module Adapter20090201
+    URI = 'https://queue.amazonaws.com/'
+    PARAMS = {'Version' => '2009-02-01'}
+
+    def create_queue(queue_name, timeout=nil)
+      params = {
+        'Action'    => 'CreateQueue',
+        'QueueName' => queue_name
+      }
+      params['DefaultVisibilityTimeout'] = timeout if timeout
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def delete_queue(queue_url)
+      params = {'Action' => 'DeleteQueue'}
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def list_queues(prefix=nil)
+      params = {'Action' => 'ListQueues'}
+      params['QueueNamePrefix'] = prefix if prefix
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params), 'QueueUrl')
+    end
+
+    def pack_attrs(attrs)
+      params = {}
+
+      if(attrs.size == 1)
+        params["AttributeName"] = attrs.first
+      else
+        i = 1
+        attrs.each do |val|
+          params["AttributeName.#{i}"] = val
+          i += 1
+        end
+      end
+
+      params
+    end
+
+    def get_queue_attributes(queue_url, *attrs)
+      params = {'Action' => 'GetQueueAttributes'}
+      if attrs.empty?
+        params.merge!(pack_attrs(['All']))
+      else
+        params.merge!(pack_attrs(attrs))
+      end
+
+      RAWS.fetch(
+        'GET',
+        queue_url,
+        PARAMS.merge(params),
+        :multiple => %w'Attribute',
+        :unpack   => %w'Attribute'
+      )
+    end
+
+    def set_queue_attributes(queue_url, attrs={})
+      params = {'Action' => 'SetQueueAttributes'}
+      params.merge!(RAWS.pack_attrs(attrs))
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def send_message(queue_url, msg)
+      params = {
+        'Action'      => 'SendMessage',
+        'MessageBody' => msg
+      }
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def receive_message(queue_url, limit=nil, timeout=nil, *attrs)
+      params = {'Action' => 'ReceiveMessage'}
+      params['MaxNumberOfMessages'] = limit   if limit
+      params['VisibilityTimeout']   = timeout if timeout
+      params.merge!(pack_attrs(attrs))
+
+      RAWS.fetch(
+        'GET',
+        queue_url,
+        PARAMS.merge(params),
+        :multiple => %w'Message Attribute',
+        :unpack   => %w'Attribute'
+      )
+    end
+
+    def change_message_visibility(queue_url, receipt_handle, timeout)
+      params = {
+        'Action'            => 'ChangeMessageVisibility',
+        'ReceiptHandle'     => receipt_handle,
+        'VisibilityTimeout' => timeout
+      }
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def delete_message(queue_url, receipt_handle)
+      params = {
+        'Action'        => 'DeleteMessage',
+        'ReceiptHandle' => receipt_handle
+      }
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def pack_permission(params)
+      ret = {}
+
+      i = 1
+      params.each do |id, permissions|
+        permissions.each do |permission|
+          ret["AWSAccountId.#{i}"] = id
+          ret["ActionName.#{i}"]   = permission
+          i += 1
+        end
+      end
+
+      ret
+    end
+
+    def add_permission(queue_url, label, permission)
+      params = {
+        'Action' => 'AddPermission',
+        'Label'  => label
+      }
+      params.merge!(pack_permission(permission))
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+
+    def remove_permission(queue_url, label)
+      params = {
+        'Action' => 'RemovePermission',
+        'Label'  => label
+      }
+
+      RAWS.fetch('GET', queue_url, PARAMS.merge(params))
+    end
+  end
+
+  extend Adapter20090201
+end

data/lib/raws/sqs.rb

@@ -0,0 +1,158 @@
+class RAWS::SQS
+  autoload :Adapter, 'raws/sqs/adapter'
+
+  class << self
+    def queue_url(queue_name)
+      data = Adapter.list_queues(
+        queue_name
+      )['ListQueuesResponse']['ListQueuesResult']
+
+      data['QueueUrl'].each do |url|
+        _queue_name = URI.parse(url).path.split('/').last
+        if _queue_name == queue_name
+          return url
+        end
+      end unless data.empty?
+    end
+
+    def create_queue(queue_name, timeout=nil)
+      self.new(
+        Adapter.create_queue(
+          queue_name,
+          timeout
+        )['CreateQueueResponse']['CreateQueueResult']['QueueUrl']
+      )
+    end
+
+    def delete_queue(queue_url)
+      Adapter.delete_queue(queue_url)
+    end
+
+    def list(prefix=nil)
+      (
+        Adapter.list_queues(
+          prefix
+        )['ListQueuesResponse']['ListQueuesResult']['QueueUrl'] || []
+      ).map do |val|
+        self.new(val)
+      end
+    end
+
+    def each(&block)
+      list.each(&block)
+    end
+
+    def [](queue_name)
+      if url = queue_url(queue_name)
+        self.new(queue_url(queue_name))
+      end
+    end
+
+    def get_attrs(queue_url, *attrs)
+      Adapter.get_queue_attributes(
+        queue_url,
+        *attrs
+      )['GetQueueAttributesResponse']['GetQueueAttributesResult']['Attribute']
+    end
+
+    def set_attrs(queue_url, attrs={})
+      Adapter.set_queue_attributes(queue_url, attrs)
+    end
+
+    def send(queue_url, msg)
+      Adapter.send_message(queue_url, msg)
+    end
+
+    def receive(queue_url, params={}, *attrs)
+      Adapter.receive_message(
+        queue_url,
+        params[:limit],
+        params[:timeout],
+        *attrs
+      )['ReceiveMessageResponse']['ReceiveMessageResult']['Message'] || []
+    end
+
+    def change_message_visibility(queue_url, handle, timeout)
+      Adapter.change_message_visibility(queue_url, handle, timeout)
+    end
+
+    def delete_message(queue_url, handle)
+      Adapter.delete_message(queue_url, handle)
+    end
+
+    def add_permission(queue_url, label, permission)
+      Adapter.add_permission(queue_url, label, permission)
+    end
+
+    def remove_permission(queue_url, label)
+      Adapter.remove_permission(queue_url, label)
+    end
+  end
+
+  class Message
+    attr_reader :queue
+    attr_reader :data
+
+    def initialize(queue, data)
+      @queue, @data = queue, data
+    end
+
+    def body
+      data['Body']
+    end
+
+    def visibility=(timeout)
+      queue.change_message_visibility data['ReceiptHandle'], timeout
+    end
+
+    def delete
+      queue.delete_message data['ReceiptHandle']
+    end
+  end
+
+  attr_reader :queue_url
+  attr_reader :queue_name
+
+  def initialize(queue_url)
+    @queue_url  = queue_url
+    @queue_name = URI.parse(@queue_url).path.split('/').last
+  end
+
+  def delete_queue
+    self.class.delete_queue(queue_url)
+  end
+
+  def get_attrs(*attrs)
+    self.class.get_attrs(queue_url, *attrs)
+  end
+
+  def set_attrs(attrs={})
+    self.class.set_attrs(queue_url, attrs)
+  end
+
+  def send(msg)
+    self.class.send(queue_url, msg)
+  end
+
+  def receive(params={}, *attrs)
+    self.class.receive(queue_url, params, *attrs).map do |val|
+      Message.new(self, val)
+    end
+  end
+
+  def change_message_visibility(handle, timeout)
+    self.class.change_message_visibility(queue_url, handle, timeout)
+  end
+
+  def delete_message(handle)
+    self.class.delete_message(queue_url, handle)
+  end
+
+  def add_permission(label, permission)
+    self.class.add_permission(queue_url, label, permission)
+  end
+
+  def remove_permission(label)
+    self.class.remove_permission(queue_url, label)
+  end
+end

data/lib/raws.rb

@@ -0,0 +1,149 @@
+require 'uri'
+require 'time'
+require 'openssl'
+
+require 'rubygems'
+require 'typhoeus'
+require 'nokogiri'
+
+module RAWS
+  include Typhoeus
+
+  class Error < StandardError
+    attr_reader :response
+    attr_reader :data
+
+    def initialize(response, data)
+      super()
+      @response, @data = response, data
+    end
+  end
+
+  class << self
+    attr_accessor :aws_access_key_id
+    attr_accessor :aws_secret_access_key
+
+    def escape(val)
+      URI.escape(val.to_s, /([^a-zA-Z0-9\-_.~]+)/n)
+    end
+
+    def sign(http_verb, base_uri, params)
+      path = {
+        'AWSAccessKeyId'   => aws_access_key_id,
+        'SignatureMethod'  => 'HmacSHA256',
+        'SignatureVersion' => '2',
+        'Timestamp'        => Time.now.utc.iso8601
+      }.merge(params).map do |key, val|
+        "#{escape(key)}=#{escape(val)}"
+      end.sort.join('&')
+
+      uri = URI.parse(base_uri)
+      "#{path}&Signature=" + escape(
+        [
+          ::OpenSSL::HMAC.digest(
+            ::OpenSSL::Digest::SHA256.new,
+            aws_secret_access_key,
+            "#{http_verb.upcase}\n#{uri.host.downcase}\n#{uri.path}\n#{path}"
+          )
+        ].pack('m').strip
+      )
+    end
+
+    def pack_attrs(attrs, replaces=nil, prefix=nil)
+      params = {}
+
+      i = 1
+      attrs.each do |key, val|
+        if !replaces.nil? && replaces.include?(key)
+          params["#{prefix}Attribute.#{i}.Replace"] = 'true'
+        end
+
+        if val.is_a? Array
+          val.each do |v|
+            params["#{prefix}Attribute.#{i}.Name"]  = key
+            params["#{prefix}Attribute.#{i}.Value"] = v
+            i += 1
+          end
+        else
+          params["#{prefix}Attribute.#{i}.Name"]  = key
+          params["#{prefix}Attribute.#{i}.Value"] = val
+          i += 1
+        end
+      end
+
+      params
+    end
+
+    def unpack_attrs(attrs)
+      ret = {}
+
+      if attrs.is_a? Array
+        attrs
+      else
+        [attrs]
+      end.map do |val|
+        name, value = val['Name'], val['Value']
+
+        if ret.key? name
+          ret[name] = [ret[name]] unless ret[name].is_a? Array
+          ret[name] << value
+        else
+          ret[name] = value
+        end
+      end if attrs
+
+      ret
+    end
+
+    def parse(doc, params={}, ret={})
+      multiple = params[:multiple] || []
+      unpack   = params[:unpack]   || []
+
+      name = nil
+      doc.children.each do |tag|
+        name = tag.name #.gsub(/([A-Z])/, '_\1').gsub(/^_/, '').downcase.to_sym
+
+        unless ret[name].is_a? Array
+          if ret.key?(name)
+            ret[name] = [ret[name]]
+          elsif multiple.include? name
+            ret[name] = []
+          end
+        end
+
+        if tag.child.is_a? Nokogiri::XML::Text
+          if ret.key? name
+            ret[name] << tag.content
+          else
+            ret[name] = tag.content
+          end
+        else
+          if ret.key? name
+            ret[name] << {}
+            parse(tag, params, ret[name].last)
+          else
+            ret[name] = {}
+            parse(tag, params, ret[name])
+          end
+        end
+      end
+      ret[name] = unpack_attrs(ret[name]) if unpack.include?(name)
+
+      ret
+    end
+
+    def fetch(http_verb, base_uri, params, options={})
+      r = get("#{base_uri}?#{sign(http_verb, base_uri, params)}")
+      data = parse(Nokogiri::XML.parse(r.body), options)
+      if 200 <= r.code && r.code <= 299
+        data
+      else
+        raise Error.new(r, data)
+      end
+    end
+  end
+
+  autoload :SDB, 'raws/sdb'
+  autoload :SQS, 'raws/sqs'
+  autoload :S3,  'raws/s3'
+end

data/spec/raws/s3_spec.rb

@@ -0,0 +1,28 @@
+require 'spec/spec_config'
+
+describe RAWS::S3::Adapter do
+  describe 'class' do
+    it 'get_service' do
+      begin
+        p RAWS::S3::Adapter.get_service
+      rescue RAWS::Error => e
+        p e.response.code
+        p e.data
+      rescue => e
+        p e
+      end
+    end
+
+    it 'put_bucket' do
+      begin
+#        p RAWS::S3::Adapter.delete_bucket('kikuchitestbucket')
+#p RAWS::S3::Adapter.put_bucket('kikuchitestbucket')
+      rescue RAWS::Error => e
+        p e.response.code
+        p e.data
+      rescue => e
+        p e
+      end
+    end
+  end
+end

data/spec/raws/sdb/model_spec.rb

@@ -0,0 +1,43 @@
+require 'spec/spec_config'
+
+class SDBModel
+  include RAWS::SDB::Model
+  self.domain_name = RAWS_SDB_DOMAIN
+end
+
+describe RAWS::SDB::Model do
+  describe 'class' do
+    it 'methods' do
+      %w'
+        create_domain
+        delete_domain
+        select
+        all
+        generate_id
+      '.each do |val|
+        SDBModel.should respond_to val.to_sym
+      end
+    end
+
+    it 'domain_name' do
+      SDBModel.domain_name.should == RAWS_SDB_DOMAIN
+    end
+  end
+
+  describe 'object' do
+    before do
+      @model = SDBModel.new
+    end
+
+    it 'methods' do
+      %w'
+        []
+        []=
+        delete
+        save
+      '.each do |val|
+        @model.should respond_to val.to_sym
+      end
+    end
+  end
+end