ey_resolver 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+coverage
+pkg

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'dm-core'
+  gem 'dm-migrations'
+  gem 'dm-aggregates'
+  gem 'dm-sqlite-adapter'
+end
+
+group :coverage do
+  gem 'simplecov', :require => false
+end

data/README.md

@@ -0,0 +1,32 @@
+# EY::Resolver
+
+Resolves a set of query options to an Array of AppEnvironment (AppDeployment)
+that best match the query. At least one query parameter must be 'app\_name'
+or 'remotes' or it raises EY::Resolver::UnconstrainedError (ArgumentError).
+
+It works by first doing a pass asking for any AppEnvironments that have the
+query arguments as substrings, keeping only those that match all query params.
+
+Next, if remotes were passed, and 'app\_name' was not, it constrains by remotes
+using [Gitable::URI](https://github.com/martinemde/gitable)'s equivalent
+matching algorithm to restrict to only those with the right remote URIs
+(public and private repo URIs should match).
+
+Lastly, it tries to discover better matches by scoring each match based on the
+number of exact matches it has. An exact match means the query param is exactly
+the full string of the matching attribute.
+
+The results are all AppEnvironments that have the same top exact match score.
+It's possible for there to be more than one result that matches equally.
+
+## Example
+
+    query = {
+      'account_name'     => 'ey',
+      'app_name'         => 'app',
+      'environment_name' => 'resolver',
+      'remotes' => ['git@github.com:engineyard/app-env-resolver.git']
+    }
+    results = EY::Resolver.awsm_resolver(query, current_user).app_environments
+    results   # An Array of AppEnvironment (AppDeployment) models that best match the query.
+

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec
+
+task :coverage => [:coverage_env, :spec]
+
+task :coverage_env do
+  ENV['COVERAGE'] = '1'
+end

data/ey_resolver.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ey_resolver/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ey_resolver"
+  s.version     = EY::Resolver::VERSION
+  s.authors     = ["Martin Emde"]
+  s.email       = ["martin.emde@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Resolves awsm models given constraints}
+  s.description = %q{Resolves apps, environments, app_environments and accounts using a set of constraints}
+
+  s.rubyforge_project = "ey_resolver"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency "gitable", "~>0.2.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~>2.0"
+end

data/lib/ey_resolver.rb

@@ -0,0 +1,12 @@
+require 'ey_resolver/query'
+require 'ey_resolver/examiner'
+require 'ey_resolver/account_resolver'
+require 'ey_resolver/app_resolver'
+require 'ey_resolver/app_env_resolver'
+require 'ey_resolver/environment_resolver'
+
+module EY
+  class Resolver
+    class UnconstrainedError < ArgumentError; end
+  end
+end

data/lib/ey_resolver/abstract_resolver.rb

@@ -0,0 +1,61 @@
+require 'ey_resolver/query'
+require 'ey_resolver/examiner'
+
+class EY::Resolver
+  class AbstractResolver
+    def self.model
+      raise "Unimplemented"
+    end
+
+    attr_reader :user, :query, :model
+
+    def initialize(user, params, model = nil)
+      @user = user
+      @query = Query.new(params)
+      @model = model || self.class.model
+    end
+
+    def matches
+      if query.unconstrained?
+        return []
+      end
+    end
+
+    def errors
+      examiner.unconstrained_errors
+    end
+
+    def suggestions
+      errors
+      examiner.suggestions
+    end
+
+    protected
+
+    def examiner
+      @examiner ||= Examiner.new(query, user)
+    end
+
+    def filter_by_remotes(candidates)
+      return candidates unless query.remotes && !query.remotes.empty?
+      candidates.select do |candidate|
+        query.remotes.any? { |uri| equivalent_remote?(candidate,uri) }
+      end
+    end
+
+    def equivalent_remote?(candidate, uri)
+      false
+    end
+
+    def best_matches(candidates)
+      groups = candidates.group_by do |candidate|
+        query.count_matches {|key,val| exact_match?(candidate, key, val)}
+      end
+      groups.fetch(groups.keys.max, [])
+    end
+
+    def exact_match?(candidate, key, val)
+      false
+    end
+  end
+end

data/lib/ey_resolver/account_resolver.rb

@@ -0,0 +1,47 @@
+require 'ey_resolver/abstract_resolver'
+
+class EY::Resolver
+  def self.account_resolver(user, params, model = nil)
+    AccountResolver.new(user, params, model)
+  end
+
+  class AccountResolver < AbstractResolver
+    def self.model
+      ::Account
+    end
+
+    def matches
+      if query.unconstrained?
+        return []
+      end
+
+      dm_query = {}
+      dm_query[:name.like]           = "%#{query.account_name}%" if query.account_name
+
+      best_matches user.accounts.all(dm_query)
+    end
+
+    def errors
+      @errors ||=
+        super ||
+        examiner.not_found_errors ||
+        []
+    end
+
+    private
+
+    def exact_match?(account, key, val)
+      case key.to_sym
+      when :remotes
+        app_uris = account.apps.map { |app| app.gitable_uri }.flatten
+        val.any? { |uri| app_uris.any? { |app_uri| app_uri.equivalent?(uri) } }
+      when :app_name
+        account.apps.any? {|app| app.name.downcase.index(val.downcase) } # partial match app if given for account
+      when :account_name
+        account.name.downcase == val.downcase
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ey_resolver/app_env_resolver.rb

@@ -0,0 +1,57 @@
+require 'ey_resolver/abstract_resolver'
+
+class EY::Resolver
+  def self.app_env_resolver(user, params, model = nil)
+    AppEnvResolver.new(user, params, model)
+  end
+
+  class AppEnvResolver < AbstractResolver
+    def self.model
+      ::AppEnvironment
+    end
+
+    def matches
+      if query.unconstrained? || query.app_unconstrained?
+        return []
+      end
+
+      dm_query = {}
+      dm_query[model.app.name.like]         = "%#{query.app_name}%"         if query.app_name
+      dm_query[model.environment.name.like] = "%#{query.environment_name}%" if query.environment_name
+      dm_query[model.app.account.name.like] = "%#{query.account_name}%"     if query.account_name
+
+      candidates = user.accounts.apps.app_environments.all(dm_query)
+      best_matches filter_by_remotes(candidates)
+    end
+
+    def errors
+      @errors ||=
+        super ||
+        examiner.app_unconstrained_errors ||
+        examiner.not_found_errors ||
+        examiner.account_scoping_errors ||
+        examiner.association_errors ||
+        examiner.env_not_found_errors ||
+        []
+    end
+
+    private
+
+    def equivalent_remote?(app_env, uri)
+      app_env.app.gitable_uri.equivalent?(uri)
+    end
+
+    def exact_match?(app_env, key, val)
+      case key.to_sym
+      when :app_name
+        app_env.app.name.downcase == val.downcase
+      when :environment_name
+        app_env.environment.name.downcase == val.downcase
+      when :account_name
+        app_env.app.account.name.downcase == val.downcase
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ey_resolver/app_resolver.rb

@@ -0,0 +1,52 @@
+require 'ey_resolver/abstract_resolver'
+
+class EY::Resolver
+  def self.app_resolver(user, params, model = nil)
+    AppResolver.new(user, params, model)
+  end
+
+  class AppResolver < AbstractResolver
+    def self.model
+      ::App
+    end
+
+    def matches
+      if query.unconstrained? || query.app_unconstrained?
+        return []
+      end
+
+      dm_query = {}
+      dm_query[:name.like]                                   = "%#{query.app_name}%"         if query.app_name
+      dm_query[model.account.name.like]                      = "%#{query.account_name}%"     if query.account_name
+
+      candidates = user.accounts.apps.all(dm_query)
+      best_matches filter_by_remotes(candidates)
+    end
+
+    def errors
+      @errors ||=
+        super ||
+        examiner.app_unconstrained_errors ||
+        examiner.not_found_errors ||
+        examiner.account_scoping_errors ||
+        []
+    end
+
+    protected
+
+    def equivalent_remote?(app, uri)
+      app.gitable_uri.equivalent?(uri)
+    end
+
+    def exact_match?(app, key, val)
+      case key.to_sym
+      when :app_name
+        app.name.downcase == val.downcase
+      when :account_name
+        app.account.name.downcase == val.downcase
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ey_resolver/environment_resolver.rb

@@ -0,0 +1,67 @@
+require 'ey_resolver/abstract_resolver'
+
+class EY::Resolver
+  def self.environment_resolver(user, params, env_class = nil)
+    EnvironmentResolver.new(user, params, env_class)
+  end
+
+  class EnvironmentResolver < AbstractResolver
+    def self.model
+      ::Environment
+    end
+
+    def matches
+      if query.unconstrained? || query.env_unconstrained?
+        return []
+      end
+
+      dm_query = {}
+      dm_query[:name.like]                           = "%#{query.environment_name}%" if query.environment_name
+      dm_query[model.account.name.like]              = "%#{query.account_name}%"     if query.account_name
+      dm_query[model.app_environments.app.name.like] = "%#{query.app_name}%"         if query.app_name
+
+      candidates = user.accounts.environments.all(dm_query)
+
+      if !query.environment_name && query.remotes
+        # if env name is not specified, and the only constraint is the remotes, require the remotes to match
+        candidates = filter_by_remotes(candidates)
+      end
+
+      best_matches candidates
+    end
+
+    def errors
+      @errors ||=
+        super ||
+        examiner.env_unconstrained_errors ||
+        examiner.not_found_errors ||
+        examiner.account_scoping_errors ||
+        examiner.association_errors ||
+        examiner.env_not_found_errors ||
+        []
+    end
+
+    private
+
+    def equivalent_remote?(env, uri)
+      app_uris = env.apps.map { |app| app.gitable_uri }.flatten
+      app_uris.any? { |app_uri| app_uri.equivalent?(uri) }
+    end
+
+    def exact_match?(env, key, val)
+      case key.to_sym
+      when :remotes
+        app_uris = env.apps.map { |app| app.gitable_uri }.flatten
+        val.any? { |uri| app_uris.any? { |app_uri| app_uri.equivalent?(uri) } }
+      when :app_name
+        env.app_environments.any? { |app_env| app_env.app.name.downcase == val.downcase }
+      when :environment_name
+        env.name.downcase == val.downcase
+      when :account_name
+        env.account.name.downcase == val.downcase
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ey_resolver/examiner.rb

@@ -0,0 +1,143 @@
+class EY::Resolver
+
+  # The accounts, apps, and envs lookups here are fairly "expensive" so
+  # the order we use them in is important.
+  #
+  # For example, we don't look at the apps matches unless app_name or remotes
+  # were specified.
+  class Examiner
+    attr_reader :query, :suggestions
+
+    def initialize(query, user)
+      @query, @user = query, user
+      problems ||= []
+      @suggestions ||= {}
+    end
+
+    def app_unconstrained_errors
+      if query.app_unconstrained?
+        return ["App name or repository remotes required."]
+      end
+    end
+
+    def env_unconstrained_errors
+      if query.env_unconstrained?
+        return ["Environment name, app name or repository remotes required."]
+      end
+    end
+
+    def unconstrained_errors
+      if query.unconstrained?
+        return ["Must search by account name, app name, remotes, or environment name."]
+      end
+    end
+
+    # Specified name was not found
+    def not_found_errors
+      problems = []
+
+      if query.account_name && accounts.empty?
+        problems << "No account found matching #{account_name}."
+      end
+
+      if query.app_constrained? && apps.empty?
+        app_name_or_remotes =
+          if app_name
+            "#{app_name}."
+          elsif query.remotes
+            "remotes:" + query.remotes.map { |uri| "\n\t#{uri}" }.join
+          else
+            "no remotes."
+          end
+        problems << "No application found matching #{app_name_or_remotes}"
+      end
+
+      if query.environment_name && envs.empty?
+        problems << "No environment found matching #{environment_name}."
+      end
+
+      return problems if problems.any?
+    end
+
+    # Account scoping is wrong
+    def account_scoping_errors
+      if !query.account_name
+        return
+      end
+
+      problems = []
+
+      if query.app_constrained? && accounts.any? && apps.any? && acc_apps.empty?
+        app_names = apps.map {|a|a.name.inspect}.join(', ')
+        problems << "Application #{app_names} found, but does not exist in account #{account_name}."
+        @suggestions[:apps] = apps
+      end
+
+      if query.environment_name && accounts.any? && envs.any? && acc_envs.empty?
+        problems << "Environment #{environment_name} found, but does not exist in account #{account_name}."
+        @suggestions[:environments] = envs
+      end
+      return problems if problems.any?
+    end
+
+    def env_not_found_errors
+      problems = []
+
+      if !query.environment_name && query.remotes && acc_envs.empty? && acc_apps.any?
+        problems << "No environment found for applications matching remotes:" + query.remotes.map { |uri| "\n\t#{uri}" }.join
+        #@suggestions[:apps] = acc_apps
+      end
+
+      return problems if problems.any?
+    end
+
+    # App doesn't match environment
+    def association_errors
+      problems = []
+
+      if query.environment_name && query.app_name && acc_envs.any? && acc_apps.any?
+        problems << "Application #{app_name} and environment #{environment_name} are not associated."
+        @suggestions[:apps] = acc_apps
+        @suggestions[:environments] = acc_envs
+      elsif query.remotes && acc_envs.any? && acc_apps.any?
+        problems << "Application #{acc_apps.map {|a|a.name.inspect}.join(', ')} and environment #{environment_name} are not associated."
+        @suggestions[:apps] = acc_apps
+        @suggestions[:environments] = acc_envs
+      end
+
+      return problems if problems.any?
+    end
+
+    def account_name
+      query.account_name && query.account_name.inspect
+    end
+
+    def app_name
+      query.app_name && query.app_name.inspect
+    end
+
+    def environment_name
+      query.environment_name && query.environment_name.inspect
+    end
+
+    def accounts
+      @accounts ||= AccountResolver.new(@user, :account_name => query.account_name).matches
+    end
+
+    def apps
+      @apps ||= AppResolver.new(@user, :app_name => query.app_name, :remotes => query.remotes).matches
+    end
+
+    def acc_apps
+      @acc_apps ||= AppResolver.new(@user, :app_name => query.app_name, :remotes => query.remotes, :account_name => query.account_name).matches
+    end
+
+    def envs
+      @envs ||= EnvironmentResolver.new(@user, :environment_name => query.environment_name, :remotes => query.remotes).matches
+    end
+
+    def acc_envs
+      @acc_envs ||= EnvironmentResolver.new(@user, :environment_name => query.environment_name, :remotes => query.remotes, :account_name => query.account_name).matches
+    end
+  end
+end