rabbitmq_http_auth_backend 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96a75df203d47f917752b3cef73ec78a6e3f6a570db3c1e92f778c380276ef1b
+  data.tar.gz: aee167ba2a0804d262a564b15a53bce8df4ccb17a243999750eec2e8cc8d59e2
+SHA512:
+  metadata.gz: 1946c3abd0c748a6cf11c16a71e52d0d16ad85ac338cd813a6f7625320511a89bda3549abe8a3827a137c9839c8492203071b319c07717217cf9859e0ad4ee8e
+  data.tar.gz: 273f0c29de8a6f6c31d8c2593e7d86bb21426e5da84c7079626766984eff535651079e3dac58202bec98b3989d7519a29cb01ef036548fa28d18acf52f38b489

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rabbitmq_http_auth_backend.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    rabbitmq_http_auth_backend (1.0.0)
+      roda (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rack (2.0.7)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rake (10.5.0)
+    roda (3.19.0)
+      rack
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  pry (~> 0.12.2)
+  rabbitmq_http_auth_backend!
+  rack-test (~> 1.1.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2019 Stanko K.R. <hey@stanko.io>
+
+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,342 @@
+# RabbitMQHttpAuthBackend
+
+Mountable Rack application that implements a configurable API for RabbitMQ's
+[rabbitmq-auth-backend-http](https://github.com/rabbitmq/rabbitmq-auth-backend-http).
+
+## Purpose
+
+RabbitMQ comes bundled with the [rabbitmq-auth-backend-http](https://github.com/rabbitmq/rabbitmq-auth-backend-http)
+plug-in. The purpose of this plug-in is to authorize each action of an user
+connected to RabbitMQ by asking a server over HTTP if the user is allowed to
+do that action.
+
+The plugin expects the server to implement four endpoints - one for
+login (`/user`), one for vhost access, one for general resources (exchanges,
+queues, topics) and one for topics.
+
+Each endpoint has to respond with a custom format to either allow or deny the
+action.
+
+This library implements all of this as a mountable Rack application. Meaning,
+after minimal configuration your application can implement the four required
+endpoints and respond with correctly formated responses.
+
+## Usage
+
+1. [Mounting the endpoint](#mounting-the-endpoint)
+2. [Configuration](#configuration)
+3. [Resolvers](#resolvers)
+4. [Versioning](#versioning)
+5. [Default configuration](#default-configuration)
+
+### Mounting the endpoint
+
+To use `RabbitMQHttpAuthBackend`, you will have to mount it within your
+Rack application. This will expose it's endpoints from your application,
+name spaced with by any prefix of your choosing.
+
+The following are examples for some popular Rack based frameworks. Note that
+`/rabbitmq/auth` is only a prefix and can be changed to whatever you desire.
+
+For **Rails** applications, add the following line to your `routes.rb` file:
+```ruby
+# /config/routes.rb
+Rails.application.routes.draw do
+  mount RabbitMQHttpAuthBackend.app => '/rabbitmq/auth'
+end
+```
+
+For **Sinatra** applications, add the following to `config.ru`:
+```ruby
+# config.ru
+map '/rabbitmq/auth' do
+  run RabbitMQHttpAuthBackend.app
+end
+```
+
+For **Hanami** applications, add the following to `config/environment.rb`:
+```ruby
+Hanami.configure do
+  mount RabbitMQHttpAuthBackend.app, at: '/rabbitmq/auth'
+end
+```
+
+For **Roda** applications, you have to call `run` from within your routing tree:
+```ruby
+class MyApp < Roda
+  route do |r|
+    r.on '/rabbitmq/auth' do
+      r.run RabbitMQHttpAuthBackend.app
+    end
+  end
+end
+```
+
+### Configuration
+
+`RabbitMQHttpAuthBackend` can be configured to suite your needs. Both the
+HTTP method as well as the names of all the endpoints are configurable in the
+following manner.
+
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure! do
+  http_method :post
+
+  user do
+    path '/anvandare'
+  end
+
+  vhost do
+    path '/vhost'
+  end
+
+  resource do
+    path '/resurs'
+  end
+
+  topic do
+    path '/amne'
+  end
+end
+```
+
+### Resolvers
+
+Resolvers are used to determine whether or not a user is allowed access to a
+particular resource. Resolvers are passed as part of the configuration. They
+can be any callable object - any object that responds to a `call` method that
+takes one argument (the params, a hash containing RabbitMQ query information).
+
+The return value of the resolver can be either `:allow` or `:deny`. If
+additional tags need to be returned alongside `:allow` return an `Array`
+containing `:allow` and an `Array` of tags - e.g. `[:allow, ['admin']]`.
+
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure! do
+  http_method :post
+
+  user do
+    path '/anvandare'
+    resolver(lambda do |params|
+      if params['username'] == 'admin'
+        return :allow
+      end
+
+      :deny
+    end)
+  end
+
+  topic do
+    resolver TopicsResolver
+  end
+end
+
+class TopicsResolver
+  def self.call(params)
+    if params['username'] == 'admin'
+      return :allow, ['admin', 'manager']
+    end
+
+    :deny
+  end
+end
+```
+
+A "native" configuration DSL is also provided. The DSL provides utility methods
+such as `username`, `password`, `vhost`, `resource`, `name`, `permission`, `ip`
+and `routing_key`. Any utility methods `allow!` and `deny!` can be used to set
+the return value (they don't have to be the return value).
+Just note that they don't stop execution!
+
+Not all methods return usable values for all resources. Here's a list:
+* user
+  - `username`
+  - `password`
+* vhost
+  - `username`
+  - `vhost`
+  - `ip`
+* resource
+  - `username`
+  - `vhost`
+  - `resource` (can return `:exchange`, `:queue` or `:topic`)
+  - `name`
+  - `permission` (can return `:configure`, `:read` or `:write`)
+* topic
+  - `username`
+  - `vhost`
+  - `resource` (can return `:topic`)
+  - `name`
+  - `permission` (can return `:configure`, `:read` or `:write`)
+  - `routing_key` (of the published message if the permission is `:write`, else of the queue binding)
+
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure! do
+  http_method :post
+
+  topic do
+    resolver do
+      if username == 'admin'
+        allow! ['admin', 'manager']
+      else
+        deny!
+      end
+    end
+  end
+end
+```
+
+### Versioning
+
+Everybody makes mistakes and changes their minds. Therefore this library
+enables you to create multiple versions of itself and mount them.
+
+There is little difference to the regular usage.
+
+Mounting:
+```ruby
+# /config/routes.rb
+Rails.application.routes.draw do
+  mount RabbitMQHttpAuthBackend.app(:v1) => '/rabbitmq/auth'
+  #                                ^^^^^
+end
+```
+
+Configuration:
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure!(:v1) do
+  #                               ^^^^^
+  # ...
+end
+```
+
+If no version is given the `:default` or global configuration is edited.
+
+### Default configuration
+
+The global default configuration can be changed by altering the configuration
+for the `:default` version.
+
+Here is the full default configuration
+
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure!(:default) do
+  http_method :get
+
+  user do
+    path '/user'
+    resolver do
+      deny!
+    end
+  end
+
+  vhost do
+    path '/vhost'
+    resolver do
+      deny!
+    end
+  end
+
+  resource do
+    path '/resource'
+    resolver do
+      deny!
+    end
+  end
+
+  topic do
+    path '/topic'
+    resolver do
+      deny!
+    end
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Gemfile
+gem 'rabbitmq_http_auth_backend'
+```
+
+Configure the library:
+
+```ruby
+# /config/initializers/rabbitmq_http_auth_backend.rb
+RabbitMQHttpAuthBackend.configure!(:v1) do
+  http_method :get
+
+  user do
+    path '/user'
+    resolver do
+      deny!
+    end
+  end
+
+  vhost do
+    path '/vhost'
+    resolver do
+      deny!
+    end
+  end
+
+  resource do
+    path '/resource'
+    resolver do
+      deny!
+    end
+  end
+
+  topic do
+    path '/topic'
+    resolver do
+      deny!
+    end
+  end
+end
+```
+
+Mount the application:
+
+```ruby
+# /config/routes.rb
+Rails.application.routes.draw do
+  mount RabbitMQHttpAuthBackend.app => '/rabbitmq/auth'
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you
+to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file
+to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/monorkin/rabbitmq_http_auth_backend/.
+
+## License
+
+This software is licensed under the MIT license. A copy of the license
+can be found in the [LICENSE.txt file](/LICENSE.txt) included with this
+software.
+
+**TL;DR** this software comes with absolutely no warranty of any kind.
+You are free to redistribute and modify the software as long as the original
+copyright notice is present in your derivative work.

data/lib/rabbitmq_http_auth_backend.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Error < StandardError; end
+
+  def self.configure!(version = nil, &block)
+    version ||= RabbitMQHttpAuthBackend::Config.default_configuration_key
+    RabbitMQHttpAuthBackend::Config.configuration[version] ||= {}
+    cfg = RabbitMQHttpAuthBackend::Config.configuration[version]
+    RabbitMQHttpAuthBackend::Config::Runtime.new(cfg).instance_eval(&block)
+    RabbitMQHttpAuthBackend::Config.version(version)
+  end
+
+  def self.app(version = nil)
+    version ||= RabbitMQHttpAuthBackend::Config.default_configuration_key
+    config = RabbitMQHttpAuthBackend::Config.new(version)
+    RabbitMQHttpAuthBackend::App.new(config).generate
+  end
+end
+
+require 'rabbitmq_http_auth_backend/version'
+require 'rabbitmq_http_auth_backend/service'
+require 'rabbitmq_http_auth_backend/config'
+require 'rabbitmq_http_auth_backend/resolver'
+require 'rabbitmq_http_auth_backend/app'

data/lib/rabbitmq_http_auth_backend/app.rb

@@ -0,0 +1,39 @@
+require 'roda'
+
+module RabbitMQHttpAuthBackend
+  class App
+    RESOURCES = %i[user vhost resource topic].freeze
+    private_constant :RESOURCES
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def generate
+      # NOTE: config has to be bound to the local scope as a variable to be
+      # accessible from within the class that is being built
+      config = self.config
+
+      Class.new(Roda) do
+        route do |r|
+          RESOURCES.map do |resource|
+            r.on(config.fetch(resource, :path)) do
+              r.is do
+                r.public_send(config.http_method) do
+                  result =
+                    RabbitMQHttpAuthBackend::Resolver
+                    .call(r.params, config.fetch(resource, :resolver))
+                  ResponseFormatter.call(result)
+                end
+              end
+            end
+          end.last
+        end
+      end.freeze.app
+    end
+  end
+end
+
+require 'rabbitmq_http_auth_backend/app/response_formatter'

data/lib/rabbitmq_http_auth_backend/app/response_formatter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class App
+    class ResponseFormatter < RabbitMQHttpAuthBackend::Service
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def call
+        action = response[0]
+        tags = response[1]
+
+        if action == :allow && tags
+          "#{action} #{tags.join(' ')}"
+        else
+          action.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rabbitmq_http_auth_backend/config.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Config
+    DEFAULT_CFG_KEY = :default
+    private_constant :DEFAULT_CFG_KEY
+
+    DENY_PROC = (proc { deny! }).freeze
+    private_constant :DENY_PROC
+
+    DEFAULT_VALUES = {
+      # HTTP
+      http_method: :get,
+      # Paths
+      user_path: '/user',
+      vhost_path: '/vhost',
+      resource_path: '/resource',
+      topic_path: '/topic',
+      # Resolvers
+      user_resolver: DENY_PROC,
+      vhost_resolver: DENY_PROC,
+      resource_resolver: DENY_PROC,
+      topic_resolver: DENY_PROC
+    }.freeze
+    private_constant :DEFAULT_VALUES
+
+    def self.configuration
+      @configuration ||= { default_configuration_key => default_configuration }
+    end
+
+    def self.reset!
+      @configuration = { default_configuration_key => default_configuration }
+    end
+
+    def self.versions
+      configuration.keys
+    end
+
+    def self.default_configuration_key
+      DEFAULT_CFG_KEY
+    end
+
+    def self.default_configuration
+      {}.merge(DEFAULT_VALUES)
+    end
+
+    def self.version(version)
+      return unless versions.include?(version)
+
+      new(version)
+    end
+
+    attr_reader :version
+
+    def initialize(version = DEFAULT_CFG_KEY)
+      @version = version.to_sym
+    end
+
+    def http_method
+      data[:http_method]
+    end
+
+    def user_path
+      sanitize_path(data[:user_path])
+    end
+
+    def user_resolver
+      data[:user_resolver]
+    end
+
+    def vhost_path
+      sanitize_path(data[:vhost_path])
+    end
+
+    def vhost_resolver
+      data[:vhost_resolver]
+    end
+
+    def resource_path
+      sanitize_path(data[:resource_path])
+    end
+
+    def resource_resolver
+      data[:resource_resolver]
+    end
+
+    def topic_path
+      sanitize_path(data[:topic_path])
+    end
+
+    def topic_resolver
+      data[:topic_resolver]
+    end
+
+    def fetch(resource, element)
+      method = "#{resource}_#{element}".to_sym
+      return nil unless respond_to?(method)
+      public_send(method)
+    end
+
+    private
+
+    def data
+      @data ||= begin
+        defaults = self.class.configuration[DEFAULT_CFG_KEY]
+        cfg = self.class.configuration[version] || {}
+        defaults.merge(cfg).freeze
+      end
+    end
+
+    def sanitize_path(path)
+      path.gsub(%r{^/}, '')
+    end
+  end
+end
+
+require 'rabbitmq_http_auth_backend/config/runtime'

data/lib/rabbitmq_http_auth_backend/config/runtime.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Config
+    class Runtime
+      attr_reader :configuration
+
+      def initialize(config = nil, key = nil)
+        @configuration =
+          config || RabbitMQHttpAuthBackend::Config.default_configuration
+        @key = key
+      end
+
+      def http_method(method)
+        configuration[:http_method] = method.to_s.downcase.to_sym
+      end
+
+      def user(&block)
+        self.class.new(configuration, :user).instance_eval(&block)
+      end
+
+      def vhost(&block)
+        self.class.new(configuration, :vhost).instance_eval(&block)
+      end
+
+      def resource(&block)
+        self.class.new(configuration, :resource).instance_eval(&block)
+      end
+
+      def topic(&block)
+        self.class.new(configuration, :topic).instance_eval(&block)
+      end
+
+      def path(path)
+        configuration["#{key}_path".to_sym] = path
+      end
+
+      def resolver(resolver = nil, &block)
+        configuration["#{key}_resolver".to_sym] = resolver || block
+      end
+
+      protected
+
+      attr_reader :key
+    end
+  end
+end

data/lib/rabbitmq_http_auth_backend/resolver.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Resolver < Service
+    class Error < RabbitMQHttpAuthBackend::Error; end
+    class NoResolverError < Error; end
+    class NonCallableResolverError < Error; end
+    class InvalidResponseError < Error; end
+
+    attr_reader :params
+    attr_reader :resolver
+
+    def initialize(params, resolver)
+      @params = params
+      @resolver = resolver || raise(NoResolverError)
+    end
+
+    def call
+      response = generate_response!
+      validate_response!(response)
+      response
+    end
+
+    private
+
+    def generate_response!
+      if resolver.is_a?(Proc) && resolver.arity.zero?
+        runtime = Runtime.new(params)
+        runtime.instance_eval(&resolver)
+        build_response(runtime)
+      elsif resolver.respond_to?(:call)
+        Array(resolver.call(params))
+      else
+        raise(NonCallableResolverError)
+      end
+    end
+
+    def validate_response!(response)
+      raise(InvalidResponseError) unless response.is_a?(Array)
+      raise(InvalidResponseError) unless %I[allow deny].include?(response.first)
+
+      true
+    end
+
+    def build_response(runtime)
+      symbol = runtime.allowed? ? :allow : :deny
+      tags = runtime.tags
+      [symbol, tags].compact
+    end
+  end
+end
+
+require 'rabbitmq_http_auth_backend/resolver/runtime'

data/lib/rabbitmq_http_auth_backend/resolver/runtime.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Resolver
+    class Runtime
+      class Error < RabbitMQHttpAuthBackend::Error; end
+      class InvalidResourceError < Error; end
+      class InvalidPermissionError < Error; end
+
+      attr_reader :params
+      attr_accessor :tags
+      attr_accessor :_allowed
+
+      def initialize(params)
+        @params = params
+        self.tags = nil
+        self._allowed = false
+      end
+
+      def allow!(tags = nil)
+        self._allowed = true
+        self.tags = tags
+      end
+
+      def deny!
+        self._allowed = false
+        self.tags = nil
+      end
+
+      def allowed?
+        _allowed == true
+      end
+
+      def denied?
+        !allowed?
+      end
+
+      def username
+        params['username']
+      end
+
+      def password
+        params['password']
+      end
+
+      def vhost
+        params['vhost']
+      end
+
+      def resource
+        @resource ||=
+          case params['resource']
+          when 'exchange' then :exchange
+          when 'queue' then :queue
+          when 'topic' then :topic
+          else raise(InvalidResourceError)
+          end
+      end
+
+      def name
+        params['name']
+      end
+
+      def permission
+        @permission ||=
+          case params['permission']
+          when 'configure' then :configure
+          when 'write' then :write
+          when 'read' then :read
+          else raise(InvalidPermissionError)
+          end
+      end
+
+      def ip
+        params['ip']
+      end
+
+      def routing_key
+        params['routing_key']
+      end
+    end
+  end
+end

data/lib/rabbitmq_http_auth_backend/service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  class Service
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def call
+      raise(NotImplementedError)
+    end
+  end
+end

data/lib/rabbitmq_http_auth_backend/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RabbitMQHttpAuthBackend
+  module Version
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
+
+    FULL = [MAJOR, MINOR, PATCH].join('.').freeze
+
+    def self.to_s
+      FULL
+    end
+  end
+
+  VERSION = Version.to_s
+end

data/rabbitmq_http_auth_backend.gemspec

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rabbitmq_http_auth_backend/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rabbitmq_http_auth_backend'
+  spec.version = RabbitMQHttpAuthBackend::Version.to_s
+  spec.authors = ['Stanko K.R.']
+  spec.email = ['me@stanko.io']
+
+  spec.summary = 'Mountable Rack application that implements a configurable '\
+                 "API for RabbitMQ's rabbitmq-auth-backend-http"
+  spec.description = spec.summary
+  spec.homepage = 'https://github.com/monorkin/rabbitmq_http_auth_backend'
+  spec.licenses = %w[MIT]
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host' to allow pushing to a single host or delete this
+  # section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = spec.homepage
+    spec.metadata['changelog_uri'] = 'https://github.com/'\
+                                     'monorkin/rabbitmq_http_auth_backend'\
+                                     '/blob/master/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added
+  # into git.
+  IGNORED_FILES = [
+    '.gitignore', '.rspec', '.travis.yml', 'Makefile', 'Rakefile',
+    'CHANGELOG.md', /^bin\/.*/
+  ].map { |p| Regexp.new(p) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end.reject { |f| IGNORED_FILES.any? { |r| r.match?(f) }  }
+
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'roda', '~> 3.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'pry', '~> 0.12.2'
+  spec.add_development_dependency 'rack-test', '~> 1.1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: rabbitmq_http_auth_backend
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stanko K.R.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Mountable Rack application that implements a configurable API for RabbitMQ's
+  rabbitmq-auth-backend-http
+email:
+- me@stanko.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- lib/rabbitmq_http_auth_backend.rb
+- lib/rabbitmq_http_auth_backend/app.rb
+- lib/rabbitmq_http_auth_backend/app/response_formatter.rb
+- lib/rabbitmq_http_auth_backend/config.rb
+- lib/rabbitmq_http_auth_backend/config/runtime.rb
+- lib/rabbitmq_http_auth_backend/resolver.rb
+- lib/rabbitmq_http_auth_backend/resolver/runtime.rb
+- lib/rabbitmq_http_auth_backend/service.rb
+- lib/rabbitmq_http_auth_backend/version.rb
+- rabbitmq_http_auth_backend.gemspec
+homepage: https://github.com/monorkin/rabbitmq_http_auth_backend
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/monorkin/rabbitmq_http_auth_backend
+  source_code_uri: https://github.com/monorkin/rabbitmq_http_auth_backend
+  changelog_uri: https://github.com/monorkin/rabbitmq_http_auth_backend/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Mountable Rack application that implements a configurable API for RabbitMQ's
+  rabbitmq-auth-backend-http
+test_files: []