cloud-queues 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Andrew Regner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+cloud-queues
+================
+
+Basic (unoffical) ruby interface into Rackspace Cloud Queues

data/lib/cloud-queues.rb

@@ -0,0 +1,11 @@
+require 'excon'
+
+require 'json'
+require 'uri'
+require 'securerandom'
+
+require_relative "cloud-queues/version"
+require_relative "cloud-queues/client"
+require_relative "cloud-queues/queue"
+require_relative "cloud-queues/message"
+require_relative "cloud-queues/claim"

data/lib/cloud-queues/claim.rb

@@ -0,0 +1,62 @@
+module CloudQueues
+  class Claim
+    include Enumerable
+
+    attr_accessor :default_ttl
+
+    attr_reader :id
+
+    def initialize(queue, id, msgs)
+      @client = queue.client
+      @queue = queue.name
+      @id = id
+
+      # request the messages if we don't already have them
+      @messages = msgs || messages
+
+      @default_ttl = 43200 # 12 hours, server max
+    end
+
+    def queue
+      Queue.new(@client, @queue)
+    end
+
+    def each(&block)
+      @messages.each(&block)
+    end
+
+    def [](index)
+      @messages[index] rescue messages[index]
+    end
+
+    def messages
+      msgs = refresh["messages"]
+      @messages = msgs.map { |message| Message.new(queue, message) }
+    end
+
+    def update(options = {})
+      options = options.select { |opt| %w[ttl grace].include?(opt.to_s) }
+      options[:ttl] ||= @default_ttl unless options["ttl"]
+      @client.request(method: :patch, path: path, body: options, expects: 204) && true
+    end
+
+    def delete
+      @client.request(method: :delete, path: path, expects: 204) && true
+    end
+    alias_method :release, :delete
+
+    def path
+      "/queues/#{@queue}/claims/#{@id}"
+    end
+
+    def age; refresh["age"]; end
+    def ttl; refresh["ttl"]; end
+
+    private
+
+    def refresh
+      @client.request(method: :get, path: path).body
+    end
+
+  end
+end

data/lib/cloud-queues/client.rb

@@ -0,0 +1,167 @@
+module CloudQueues
+  class Client
+
+    attr_accessor :client_id
+    attr_accessor :token
+    attr_accessor :tenant
+  
+    def initialize(options = {})
+      [:username, :api_key].each do |arg|
+        raise ArgumentError.new "#{arg} is a required argument." unless options[arg]
+      end if options[:token].nil? and options[:tenant].nil?
+  
+      @client_id = SecureRandom.uuid
+  
+      options.each_pair {|k, v| instance_variable_set("@#{k}".to_sym, v) }
+      authenticate!
+    end
+  
+    def create(name)
+      request(method: :put, path: "/queues/#{name}", expects: 201)
+      Queue.new(self, name)
+    end
+  
+    def get(name)
+      request(method: :head, path: "/queues/#{name}", expects: 204)
+      Queue.new(self, name)
+    end
+  
+    def queues
+      response = request_all("queues", method: :get, path: "/queues", expects: [200, 204])
+
+      return [] if response.status == 204
+
+      response.body["queues"].map do |queue|
+        Queue.new(self, queue["name"])
+      end
+    end
+  
+    def authenticate!
+      @client = Excon.new("https://identity.api.rackspacecloud.com")
+      @base_path = nil
+
+      if @token.nil?
+        request = {auth: {"RAX-KSKEY:apiKeyCredentials" => {username: @username, apiKey: @api_key}}}
+        response = request(method: :post, path: "/v2.0/tokens", body: request)
+        @token = response.body["access"]["token"]["id"]
+      else
+        # try the current token
+        request = {auth: {tenantId: @tenant, token: {id: @token}}}
+        response = request(method: :post, path: "/v2.0/tokens", body: request)
+      end
+
+      url_type = @internal ? "internalURL" : "publicURL"
+      queues = response.body["access"]["serviceCatalog"].select{|service| service["name"] == "cloudQueues" }
+      endpoints = queues[0]["endpoints"]
+
+      url = if @region.nil?
+              # pick the first region
+              # TODO when cloud queues goes GA, change this to response.body["access"]["user"]["RAX-AUTH:defaultRegion"]
+              endpoints[0][url_type].split('/')
+            else
+              endpoint = endpoints.select { |endpoint| endpoint["region"] == @region.to_s.upcase }
+              raise ArgumentError.new "Region #{@region.to_s.upcase} does not exist!" if endpoint.count == 0
+              endpoint[0][url_type].split('/')
+            end
+  
+      host = url[0..2].join('/')
+      @base_path = "/" + url[3..-1].join('/')
+      @tenant = url[-1]
+  
+      @client = Excon.new(host)
+    end
+  
+    def request(options = {}, second_try = false)
+      if options[:body] and options[:body].class != String
+        options[:body] = options[:body].to_json
+      end
+  
+      options[:path] = "#{@base_path}#{options[:path]}" unless options[:path].start_with?(@base_path)
+  
+      options[:headers] ||= {}
+      options[:headers]["Content-Type"] = "application/json" if options[:body]
+      options[:headers]["Accept"] = "application/json"
+      options[:headers]["Client-ID"] = @client_id
+      options[:headers]["X-Auth-Token"] = @token if @token
+      options[:headers]["X-Project-ID"] = @tenant
+  
+      options[:tcp_nodelay] = true if options[:tcp_nodelay].nil?
+      options[:expects] ||= 200
+  
+      puts options if @debug
+  
+      begin
+        response = @client.request(options)
+      rescue Excon::Errors::SocketError => e
+        raise unless e.message.include?("EOFError") or second_try
+
+        # this happens when the server closes the keep-alive socket and
+        # Excon doesn't realize it yet.
+        @client.reset
+        return request(options, true)
+      rescue Excon::Errors::Unauthorized => e
+        raise if second_try or @token.nil?
+
+        # Our @token probably expired, re-auth and try again
+        @token = nil
+        authenticate!
+        @client.reset # for good measure
+        return request(options, true)
+      end
+
+      begin
+        response.body = JSON.load(response.body) if (response.get_header("Content-Type") || "").include?("application/json")
+      rescue
+        # the api seems to like to give a json content type for a "204 no content" response
+      end
+
+      return response
+    end
+
+    def request_all(collection_key, options = {})
+      begin
+        absolute_limit = options[:query][:limit]
+        limit = [absolute_limit, 10].min
+        options[:query][:limit] = limit if options[:query][:limit]
+      rescue
+        absolute_limit = Float::INFINITY
+        limit = 10
+      end
+
+      response = request(options)
+
+      if collection_key and response.status != 204
+        # the next href link will have the query represented in it
+        options.delete :query
+
+        collection = response.body[collection_key]
+
+        while response.body[collection_key].count >= limit and collection.count < absolute_limit
+          next_link = response.body["links"].select{|l| l["rel"] == "next" }[0]["href"]
+          options[:path] = set_query_from(options[:path], next_link)
+
+          response = request(options)
+
+          break if response.status == 204
+          collection += response.body[collection_key]
+        end
+
+        response.body[collection_key] = collection
+      end
+
+      return response
+    end
+
+    private
+
+    # I would just like to comment that this is only necessary because the API does not return the correct
+    # href for the next page.  The tenant id (account number) is missing from between the /v1 and /queues.
+    def set_query_from(original, new_uri)
+      original = URI.parse(original)
+      new_query = URI.parse(new_uri).query
+      original.query = new_query
+      return original.to_s
+    end
+  
+  end
+end

data/lib/cloud-queues/message.rb

@@ -0,0 +1,51 @@
+module CloudQueues
+  class Message
+
+    attr_reader :id, :body
+
+    def initialize(queue, message)
+      @client = queue.client
+      @queue = queue.name
+
+      href = URI.parse(message["href"])
+      @id = href.path.split('/')[-1]
+      @claim = href.query.match(/(^|&)claim_id=([^&]+)/)[2] rescue nil
+      @body = message["body"]
+      @age = message["age"]
+      @ttl = message["ttl"]
+    end
+
+    def delete!
+      @client.request(method: :delete, path: path, expects: 204) && true
+    end
+
+    def queue
+      Queue.new(@client, @queue)
+    end
+
+    def claim
+      @claim.nil? ? nil : Claim.new(queue, @claim, nil)
+    end
+
+    def to_hash
+      {ttl: @ttl, body: @body}
+    end
+
+    def age; @age; end
+    def ttl; @ttl; end
+
+    # beware using this path method.  it could return a path with a query argument
+    # at the end.  this is to ensure the claim_id is provided whenever operations
+    # against this message are performed, however it could end up causing string
+    # formatting problems depending on how it's used.
+    def path
+      query = @claim ? "?claim_id=#{@claim}" : ""
+      "/queues/#{@queue}/messages/#{@id}#{query}"
+    end
+
+    def [](key)
+      @body[key]
+    end
+
+  end
+end

data/lib/cloud-queues/queue.rb

@@ -0,0 +1,144 @@
+module CloudQueues
+  class Queue
+
+    attr_accessor :default_ttl
+
+    attr_reader :name, :client
+
+    def initialize(client, name)
+      @client = client
+      @name = name
+
+      # TODO maybe make these defaults on the client or something, this isn't going
+      # to always work out the way we want
+      @default_ttl = 1209600 # 14 days, server max
+
+      @default_claim_ttl = 43200 # 12 hours, server max
+      @default_claim_grace = 300 # 5 minutes, arbitrary
+    end
+
+    def messages(options = {})
+      if options[:ids]
+        raise ArgumentError.new "Only 20 or less message IDs may be specified" if options[:ids].count > 20
+        allowed_query = %w[ids claim_id]
+      else
+        allowed_query = %w[marker limit echo include_claimed]
+      end
+
+      options = options.select { |opt| allowed_query.include?(opt.to_s) }
+
+      # Excon likes to CGI.escape values in a query hash, so this has to be handled manually
+      if options[:ids]
+        query = "?ids=#{options.delete(:ids).join(',')}"
+        options.each_pair do |key, value|
+          query << "&#{key}=#{CGI.escape(value)}"
+        end
+        options = query
+      end
+
+      response = @client.request_all(options.class == String ? nil : "messages",
+                                     method: :get, path: "#{path}/messages", expects: [200, 204], query: options)
+      return [] if response.status == 204
+      response.body.class == Hash ? process_messages(response.body["messages"]) : process_messages(response.body)
+    end
+
+    def get(id, options = {})
+      options = options[:claim_id] ? {claim_id: options[:claim_id]} : {}
+      msgs = @client.request(method: :get, path: "#{path}/messages/#{id}", query: options)
+      process_messages([msgs.body])[0]
+    end
+
+    def put(*msgs)
+      raise ArgumentError.new("Only 10 or less messages may be given at once") if msgs.count > 10
+
+      msgs = msgs.map do |message|
+        begin
+          if message.class == Message
+            message.to_hash
+          elsif message[:body] or message["body"]
+            {
+              ttl: message[:ttl] || message["ttl"] || @default_ttl,
+              body: message[:body] || message["body"],
+            }
+          else
+            { ttl: @default_ttl, body: message }
+          end
+        rescue
+          { ttl: @default_ttl, body: message }
+        end
+      end
+
+      # TODO this should probably do something with a body["partial"] == true response
+      resources = @client.request(method: :post, path: "#{path}/messages", body: msgs, expects: 201).body["resources"]
+      resources.map { |resource| URI.parse(resource).path.split('/')[-1] }
+    end
+
+    def claim(options = {})
+      query = options[:limit] ? {limit: options[:limit]} : {}
+      body = {
+        ttl: options[:ttl] || options["ttl"] || @default_claim_ttl,
+        grace: options[:grace] || options["grace"] || @default_claim_grace,
+      }
+      response = @client.request(method: :post, path: "#{path}/claims", body: body, query: query, expects: [201, 204])
+      return [] if response.status == 204
+      claim_id = URI.parse(response.get_header("Location")).path.split('/')[-1]
+      process_claim(claim_id, response.body)
+    end
+
+    def delete_messages(*ids)
+      query = "?ids=#{ids.join(',')}"
+      @client.request(method: :delete, path: "#{path}/messages", expects: 204, query: query) && true
+    end
+
+    def delete!
+      @client.request(method: :delete, path: "#{path}", expects: 204) && true
+    end
+  
+    def [](key)
+      metadata[key]
+    end
+  
+    def []=(key, value)
+      new_data = metadata
+      new_data[key] = value
+      @client.request(method: :put, path: "#{path}/metadata", body: new_data, expects: 204) && true
+    end
+  
+    def metadata
+      @client.request(method: :get, path: "#{path}/metadata").body
+    end
+  
+    def metadata=(new_data)
+      @client.request(method: :put, path: "#{path}/metadata", body: new_data, expects: 204) && true
+    end
+
+    def stats
+      @client.request(method: :get, path: "#{path}/stats").body
+    end
+
+    def stat(name)
+      stats["messages"][name.to_s]
+    end
+
+    def claimed; stat(:claimed); end
+    def free; stat(:free); end
+    def total; stat(:total); end
+    def newest; stat(:newest); end
+    def oldest; stat(:oldest); end
+
+    def path
+      "/queues/#{@name}"
+    end
+
+    private
+
+    def process_messages(msgs)
+      msgs.map { |message| Message.new(self, message) }
+    end
+
+    def process_claim(claim_id, msgs)
+      Claim.new(self, claim_id, process_messages(msgs))
+    end
+
+  end
+end

data/lib/cloud-queues/version.rb

@@ -0,0 +1,3 @@
+module CloudQueues
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: cloud-queues
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Regner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'cloud-queues
+
+  ================
+
+
+  Basic (unoffical) ruby interface into Rackspace Cloud Queues
+
+'
+email:
+- andrew.regner@rackspace.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cloud-queues/claim.rb
+- lib/cloud-queues/client.rb
+- lib/cloud-queues/message.rb
+- lib/cloud-queues/queue.rb
+- lib/cloud-queues/version.rb
+- lib/cloud-queues.rb
+- LICENSE
+- README.md
+homepage: https://github.com/adregner/cloud-queues
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Basic (unoffical) ruby interface into Rackspace Cloud Queues
+test_files: []