dmexe_rabbitmq_http_api_client 0.3.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWMyNWYyYTBiMTI2OTFiYjMzODY1ZmE2Njc5OTBlYTdlM2NmNjMxMQ==
+  data.tar.gz: !binary |-
+    NzliMTVmMjViOTU4OGY5Y2IwZmQyYTE3Y2UxYjhlYjk2MmY2ZGEwMw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    N2Y0MTYzZjRhMTg3NGJiNDM2Y2Y3NDNjY2IwNWViOWVhMTZlYzkzNjk1ZTM0
+    ZDJmZmZmMmNiNzc3ZDNjNWY1YzQ1YTFhNThmOGIzMjcyNDU3YTNjMzFiNDIy
+    OGMwYTI4MTlkMmE2NDA1NjAyNzgwYTFjMjNjZDMyNmIwYzM2ZDE=
+  data.tar.gz: !binary |-
+    YWM1MjM5ZDdiYTQ5MWMzM2FhNTA4Yjc4Y2MyZjEyN2M3ZTMzOThkOTI0ZTY5
+    MDI1ZWY1YjIwODNkMzRlMDNhM2YyZjc4MzJjMWE1NTkyMTcwNmUxODA2M2E3
+    YTQ4MmI3MjA2ZjZkYmRjYTQxY2U1MTM3ZTYxNGQ2NDlkZTkzZGM=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/ChangeLog.md

@@ -0,0 +1,19 @@
+## Changes Between 0.1.0 and 0.2.0
+
+### Support for more HTTP API operations
+
+ * Operations on queues
+ * Operations on users
+ * Operations on permissions
+ * Operations on parameters
+ * Operations on policies
+
+
+## Original Release: 0.1.0
+
+### Support for many HTTP API operations
+
+ * Status overview
+ * Cluster nodes information
+ * Operations on exchanges, queues, bindings
+ * Operations on connections

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem "rspec"
+  gem "json"
+  gem "bunny", ">= 0.9.0.pre3"
+end
+
+# Specify your gem's dependencies in superintendent.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michael Klishin
+
+MIT License
+
+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,328 @@
+# RabbitMQ HTTP API Client for Ruby
+
+This gem is a RabbitMQ HTTP API Client for Ruby. It supports
+
+ * Getting cluster overview information
+ * Getting cluster nodes status (# file descriptors used, RAM consumption and so on)
+ * Getting information about exchanges, queues, bindings
+ * Closing client connections
+ * Getting information about vhosts, users, permissions
+
+and will support more HTTP API features in the future
+
+ * Publishing messages via HTTP
+ * Operations on components/extensions
+ * Operations on federation policies
+
+## Supported Ruby Versions
+
+ * MRI 1.9.3
+ * JRuby 1.7+
+ * Rubinius 2.0+
+ * MRI 1.9.2
+ * MRI 1.8.7
+
+## Supported RabbitMQ Versions
+
+ * RabbitMQ 3.x
+ * RabbitMQ 2.x
+
+All versions require [RabbitMQ Management UI plugin](http://www.rabbitmq.com/management.html) to be installed and enabled.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rabbitmq_http_api_client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rabbitmq_http_api_client
+
+## Usage
+
+To require the client:
+
+``` ruby
+require "rabbitmq/http/client"
+```
+
+### Specifying Endpoint and Credentials
+
+Use `RabbitMQ::HTTP::Client#connect` to specify RabbitMQ HTTP API endpoint (e.g. `http://127.0.0.1:15672`) and credentials:
+
+``` ruby
+require "rabbitmq/http/client"
+
+endpoint = "http://127.0.0.1:55672"
+client = RabbitMQ::HTTP::Client.new(endpoint, :username => "guest", :password => "guest")
+```
+
+### Client API Design Overview
+
+All client methods return arrays or hash-like structures that can be used
+like JSON, via `Hash#[]` or regular method access:
+
+``` ruby
+r = client.overview
+
+puts r[:rabbitmq_version]
+puts r.erlang_version
+```
+
+
+
+### Node and Cluster Status
+
+``` ruby
+# Get cluster information overview
+h     = client.overview
+
+# List cluster nodes with detailed status info for each one of them
+nodes = client.list_nodes
+n     = nodes.first
+puts n.sockets_used
+puts n.mem_used
+puts n.run_queue
+
+# Get detailed status of a node
+n     = client.node_info("rabbit@localhost")
+puts n.disk_free
+puts n.proc_used
+puts n.fd_total
+
+# Get Management Plugin extension list
+xs    = client.list_extensions 
+
+# List all the entities (vhosts, queues, exchanges, bindings, users, etc)
+defs  = client.list_definitions
+```
+
+### Operations on Connections
+
+``` ruby
+# List all connections to a node
+conns = client.list_connections
+conn  = conns.first
+puts conn.name
+puts conn.client_properties.product
+
+# Get a connection information by name
+conns = client.list_connections
+conn  = client.connection_info(conns.first.name)
+puts conn.name
+puts conn.client_properties.product
+
+# Forcefully close a connection
+conns = client.list_connections
+client.close_connection(conns.first.name)
+```
+
+### Operations on Channels
+
+``` ruby
+# List all channels
+channs = client.list_channels
+ch     = channs.first
+puts ch.number
+puts ch.prefetch_count
+puts ch.name
+
+
+# Get a channel information by name
+conns = client.list_channels
+conn  = client.channel_info(conns.first.name)
+puts conn.name
+```
+
+### Operations on Exchanges
+
+``` ruby
+# List all exchanges in the cluster
+xs = client.list_exchanges
+x  = xs.first
+
+puts x.type
+puts x.name
+puts x.vhost
+puts x.durable
+puts x.auto_delete
+
+# List all exchanges in a vhost
+xs = client.list_exchanges("myapp.production")
+x  = xs.first
+
+puts x.type
+puts x.name
+puts x.vhost
+
+# Get information about an exchange in a vhost
+x  = client.exchange_info("/", "log.events")
+
+puts x.type
+puts x.name
+puts x.vhost
+
+# List all exchanges in a vhost for which an exchange is the source
+client.list_bindings_by_source("/", "log.events")
+
+# List all exchanges in a vhost for which an exchange is the destination
+client.list_bindings_by_destination("/", "command.handlers.email")
+```
+
+### Operations on Queues
+
+``` ruby
+# List all queues in a node
+qs = client.list_queues
+q  = qs.first
+
+puts q.name
+puts q.auto_delete
+puts q.durable
+puts q.backing_queue_status
+puts q.active_consumers
+
+
+# Declare a queue
+client.declare_queue("/", "collector1.megacorp.local", :durable => false, :auto_delete => true)
+
+# Delete a queue
+client.delete_queue("/", "collector1.megacorp.local")
+
+# List bindings for a queue
+bs = client.list_queue_bindings("/", "collector1.megacorp.local")
+
+# Purge a queue
+client.purge_queue("/", "collector1.megacorp.local")
+
+# Fetch messages from a queue
+ms = client.get_messages("/", "collector1.megacorp.local", :count => 10, :requeue => false, :encoding => "auto")
+m  = ms.first
+
+puts m.properties.content_type
+puts m.payload
+puts m.payload_encoding
+```
+
+### Operations on Bindings
+
+``` ruby
+# List all bindings
+bs = client.list_bindings
+b  = bs.first
+
+puts b.destination
+puts b.destination_type
+puts b.source
+puts b.routing_key
+puts b.vhost
+
+# List all bindings in a vhost
+bs = client.list_bindings("/")
+
+# List all binsings between an exchange and a queue
+bs = client.list_bindings_between_queue_and_exchange("/", "collector1.megacorp.local", "log.events")
+```
+
+### Operations on Vhosts
+
+``` ruby
+# List all vhosts
+vs = client.list_vhosts
+v  = vs.first
+
+puts v.name
+puts v.tracing
+
+# Get information about a vhost
+v  = client.vhost_info("/")
+
+puts v.name
+puts v.tracing
+
+# Create a vhost
+client.create_vhost("myapp.staging")
+
+# Delete a vhost
+client.delete_vhost("myapp.staging")
+```
+
+### Operations on Users
+
+``` ruby
+# List all users
+us = client.list_users
+u  = us.first
+
+puts u.name
+puts u.password_hash
+puts u.tags
+
+# Get information about a user
+u  = client.user_info("guest")
+
+puts u.name
+puts u.password_hash
+puts u.tags
+
+# Update information about a user
+client.update_user("myapp", :tags => "services", :password => "t0ps3krEt")
+
+# Delete a user
+client.delete_user("myapp")
+```
+
+### Operations on Permissions
+
+``` ruby
+# List all permissions
+ps = client.list_permissions
+
+puts p.user
+puts p.read
+puts p.write
+puts p.configure
+puts p.vhost
+
+# List all permissions in a vhost
+ps = client.list_permissions("/")
+
+puts p.user
+puts p.read
+puts p.write
+puts p.configure
+puts p.vhost
+
+# List permissions of a user
+ps = client.user_permissions("guest")
+
+# List permissions of a user in a vhost
+ps = client.list_permissions_of("/", "guest")
+
+# Update permissions of a user in a vhost
+ps = client.update_permissions_of("/", "guest", :write => ".*", :read => ".*", :configure => ".*")
+
+# Clear permissions of a user in a vhost
+ps = client.clear_permissions_of("/", "guest")
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## License & Copyright
+
+Double-licensed under the MIT and Mozilla Public License (same as RabbitMQ).
+
+(c) Michael S. Klishin, 2012-2013.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rabbitmq/http/client.rb

@@ -0,0 +1,343 @@
+require "hashie"
+require "faraday"
+require "faraday_middleware"
+require "multi_json"
+
+# for URI encoding
+require "cgi"
+
+module RabbitMQ
+  module HTTP
+    class Client
+
+      #
+      # API
+      #
+
+      def self.connect(endpoint, options = {})
+        new(endpoint, options)
+      end
+
+      def initialize(endpoint, options = {})
+        @endpoint = endpoint
+        @options  = options
+
+        initialize_connection(endpoint, options)
+      end
+
+      def overview
+        decode_resource(@connection.get("/api/overview"))
+      end
+
+      def list_nodes
+        decode_resource_collection(@connection.get("/api/nodes"))
+      end
+
+      def node_info(name)
+        decode_resource(@connection.get("/api/nodes/#{uri_encode(name)}"))
+      end
+
+      def list_extensions
+        decode_resource_collection(@connection.get("/api/extensions"))
+      end
+
+      def list_definitions
+        decode_resource(@connection.get("/api/definitions"))
+      end
+
+      def upload_definitions(defs)
+        raise NotImplementedError.new
+      end
+
+      def list_connections
+        decode_resource_collection(@connection.get("/api/connections"))
+      end
+
+      def connection_info(name)
+        decode_resource(@connection.get("/api/connections/#{uri_encode(name)}"))
+      end
+
+      def close_connection(name)
+        decode_resource(@connection.delete("/api/connections/#{uri_encode(name)}"))
+      end
+
+      def list_channels
+        decode_resource_collection(@connection.get("/api/channels"))
+      end
+
+      def channel_info(name)
+        decode_resource(@connection.get("/api/channels/#{uri_encode(name)}"))
+      end
+
+      def list_exchanges(vhost = nil)
+        path = if vhost.nil?
+                 "/api/exchanges"
+               else
+                 "/api/exchanges/#{uri_encode(vhost)}"
+               end
+
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def exchange_info(vhost, name)
+        decode_resource(@connection.get("/api/exchanges/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+      def update_exchange(vhost, name, attributes)
+        response = @connection.put("/api/exchanges/#{uri_encode(vhost)}/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+
+      def delete_exchange(vhost, name)
+        decode_resource(@connection.delete("/api/exchanges/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+      def list_bindings_by_source(vhost, exchange)
+        decode_resource_collection(@connection.get("/api/exchanges/#{uri_encode(vhost)}/#{uri_encode(exchange)}/bindings/source"))
+      end
+
+      def list_bindings_by_destination(vhost, exchange)
+        decode_resource_collection(@connection.get("/api/exchanges/#{uri_encode(vhost)}/#{uri_encode(exchange)}/bindings/destination"))
+      end
+
+      def list_queues(vhost = nil)
+        path = if vhost.nil?
+                 "/api/queues"
+               else
+                 "/api/queues/#{uri_encode(vhost)}"
+               end
+
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def queue_info(vhost, name)
+        decode_resource(@connection.get("/api/queues/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+      def declare_queue(vhost, name, attributes)
+        response = @connection.put("/api/queues/#{uri_encode(vhost)}/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+
+      def delete_queue(vhost, name)
+        decode_resource(@connection.delete("/api/queues/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+      def list_queue_bindings(vhost, queue)
+        decode_resource_collection(@connection.get("/api/queues/#{uri_encode(vhost)}/#{uri_encode(queue)}/bindings"))
+      end
+
+      def purge_queue(vhost, name)
+        decode_resource(@connection.delete("/api/queues/#{uri_encode(vhost)}/#{uri_encode(name)}/contents"))
+      end
+
+      def get_messages(vhost, name, options)
+        response = @connection.post("/api/queues/#{uri_encode(vhost)}/#{uri_encode(name)}/get") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(options)
+        end
+        decode_resource_collection(response)
+      end
+
+
+      def list_bindings(vhost = nil)
+        path = if vhost.nil?
+                 "/api/bindings"
+               else
+                 "/api/bindings/#{uri_encode(vhost)}"
+               end
+
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def list_bindings_between_queue_and_exchange(vhost, queue, exchange)
+        decode_resource_collection(@connection.get("/api/bindings/#{uri_encode(vhost)}/e/#{uri_encode(exchange)}/q/#{uri_encode(queue)}"))
+      end
+
+
+
+
+      def list_vhosts
+        decode_resource_collection(@connection.get("/api/vhosts"))
+      end
+
+      def vhost_info(name)
+        decode_resource(@connection.get("/api/vhosts/#{uri_encode(name)}"))
+      end
+
+      def create_vhost(name)
+        response = @connection.put("/api/vhosts/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+        end
+        decode_resource(response)
+      end
+
+      def delete_vhost(name)
+        decode_resource(@connection.delete("/api/vhosts/#{uri_encode(name)}"))
+      end
+
+
+
+      def list_permissions(vhost = nil)
+        path = if vhost
+                 "/api/vhosts/#{uri_encode(vhost)}/permissions"
+               else
+                 "/api/permissions"
+               end
+
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def list_permissions_of(vhost, user)
+        decode_resource(@connection.get("/api/permissions/#{uri_encode(vhost)}/#{uri_encode(user)}"))
+      end
+
+      def update_permissions_of(vhost, user, attributes)
+        response = @connection.put("/api/permissions/#{uri_encode(vhost)}/#{uri_encode(user)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+
+      def clear_permissions_of(vhost, user)
+        decode_resource(@connection.delete("/api/permissions/#{uri_encode(vhost)}/#{uri_encode(user)}"))
+      end
+
+
+
+      def list_users
+        decode_resource_collection(@connection.get("/api/users"))
+      end
+
+      def user_info(name)
+        decode_resource(@connection.get("/api/users/#{uri_encode(name)}"))
+      end
+
+      def update_user(name, attributes)
+        response = @connection.put("/api/users/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+      alias create_user update_user
+
+      def delete_user(name)
+        decode_resource(@connection.delete("/api/users/#{uri_encode(name)}"))
+      end
+
+      def user_permissions(name)
+        decode_resource_collection(@connection.get("/api/users/#{uri_encode(name)}/permissions"))
+      end
+
+      def whoami
+        decode_resource(@connection.get("/api/whoami"))
+      end
+
+
+
+      def list_policies(vhost = nil)
+        path = if vhost
+                 "/api/policies/#{uri_encode(vhost)}"
+               else
+                 "/api/policies"
+               end
+
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def list_policies_of(vhost, name = nil)
+        path = if name
+                 "/api/policies/#{uri_encode(vhost)}/#{uri_encode(name)}"
+               else
+                 "/api/policies/#{uri_encode(vhost)}"
+               end
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def update_policies_of(vhost, name, attributes)
+        response = @connection.put("/api/policies/#{uri_encode(vhost)}/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+
+      def clear_policies_of(vhost, name)
+        decode_resource(@connection.delete("/api/policies/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+
+
+
+      def list_parameters(component = nil)
+        path = if component
+                 "/api/parameters/#{uri_encode(component)}"
+               else
+                 "/api/parameters"
+               end
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def list_parameters_of(component, vhost, name = nil)
+        path = if name
+                 "/api/parameters/#{uri_encode(component)}/#{uri_encode(vhost)}/#{uri_encode(name)}"
+               else
+                 "/api/parameters/#{uri_encode(component)}/#{uri_encode(vhost)}"
+               end
+        decode_resource_collection(@connection.get(path))
+      end
+
+      def update_parameters_of(component, vhost, name, attributes)
+        response = @connection.put("/api/parameters/#{uri_encode(component)}/#{uri_encode(vhost)}/#{uri_encode(name)}") do |req|
+          req.headers['Content-Type'] = "application/json"
+          req.body = MultiJson.dump(attributes)
+        end
+        decode_resource(response)
+      end
+
+      def clear_parameters_of(component, vhost, name)
+        decode_resource(@connection.delete("/api/parameters/#{uri_encode(component)}/#{uri_encode(vhost)}/#{uri_encode(name)}"))
+      end
+
+
+
+      def aliveness_test(vhost)
+        r = @connection.get("/api/aliveness-test/#{uri_encode(vhost)}")
+        r.body["status"] == "ok"
+      end
+
+
+      protected
+
+      def initialize_connection(endpoint, options = {})
+        @connection = Faraday.new(:url => endpoint) do |conn|
+          conn.basic_auth options.fetch(:username, "guest"), options.fetch(:password, "guest")
+          conn.use        FaradayMiddleware::FollowRedirects, :limit => 3
+          conn.response   :json, :content_type => /\bjson$/
+
+          conn.adapter    options.fetch(:adapter, Faraday.default_adapter)
+        end
+      end
+
+      def uri_encode(s)
+        CGI.escape(s)
+      end
+
+      def decode_resource(response)
+        Hashie::Mash.new(response.body)
+      end
+
+      def decode_resource_collection(response)
+        response.body.map { |i| Hashie::Mash.new(i) }
+      end
+    end # Client
+  end # HTTP
+end # RabbitMQ