ey-core 3.0.0

data/lib/ey-core/client/mock.rb

@@ -0,0 +1,288 @@
+class Ey::Core::Client::Mock
+  include Ey::Core::Client::Shared
+
+  include Ey::Core::Mock::Params
+  include Ey::Core::Mock::Resources
+  include Ey::Core::Mock::Searching
+  include Ey::Core::Mock::Util
+  include Ey::Core::Mock::Helper
+  extend Ey::Core::Mock::Util
+
+  def self.for(type, options={})
+    case type
+    when :server
+      client = Ey::Core::Client::Mock.for(:user)
+      server_options = options[:server] || {}
+
+      account_name     = server_options.fetch(:account_name, SecureRandom.hex(4))
+      location         = server_options.fetch(:location, "us-west-2")
+      environment_name = server_options.fetch(:environment_name, SecureRandom.hex(4))
+
+      account = client.accounts.create!(name: account_name)
+
+      provider = account.providers.create!(type: :aws)
+      environment = create_environment(account: account, name: environment_name)
+      environment.servers.first
+    when :user
+      user = Ey::Core::Client::Mock.for(:consumer).users.create!(
+        {
+          :name  => "#{SecureRandom.hex(3)} #{SecureRandom.hex(3)}",
+          :email => "#{SecureRandom.hex(8)}@example.org",
+        }.merge(options[:user] || {})
+      )
+      Ey::Core::Client.new(token: user.token)
+    when :consumer
+      Ey::Core::Client.new({auth_id: SecureRandom.hex(8), auth_key: SecureRandom.hex(16)}.merge(options[:consumer] || {}))
+    end
+  end
+
+  def self.data
+    @data ||= Hash.new do |h,k|
+      h[k] = begin
+               cc_id     = self.uuid
+               custom_id = self.uuid
+               dc_id     = self.uuid
+               app_id    = self.uuid
+               deis_id   = self.uuid
+               components = {
+                 cc_id => {
+                   "created_at" => Time.now.to_s,
+                   "deleted_at" => nil,
+                   "id"         => cc_id,
+                   "name"       => "cluster_cookbooks",
+                   "updated_at" => Time.now.to_s,
+                   "uri"        => "git://github.com/engineyard/cluster_cookbooks.git",
+                 },
+                 custom_id => {
+                   "created_at" => Time.now.to_s,
+                   "deleted_at" => nil,
+                   "id"         => custom_id,
+                   "name"       => "custom_cookbooks",
+                   "updated_at" => Time.now.to_s,
+                   "uri"        => "git://github.com/engineyard/cluster_cookbooks.git",
+                 },
+                 dc_id => {
+                   "created_at" => Time.now.to_s,
+                   "deleted_at" => nil,
+                   "id"         => dc_id,
+                   "name"       => "default_cookbooks",
+                   "updated_at" => Time.now.to_s,
+                   "uri"        => "git://github.com/engineyard/cloud_cookbooks.git",
+                 },
+                 app_id => {
+                   "created_at" => Time.now.to_s,
+                   "deleted_at" => nil,
+                   "id"         => app_id,
+                   "name"       => "default_deployer",
+                   "updated_at" => Time.now.to_s,
+                   "uri"        => "git://github.com/engineyard/engineyard-serverside.git",
+                 },
+                 deis_id => {
+                   "created_at" => Time.now.to_s,
+                   "deleted_at" => nil,
+                   "id"         => deis_id,
+                   "name"       => "deis",
+                   "updated_at" => Time.now.to_s,
+                   "uri"        => "git://github.com/deis/deis.git",
+                 }
+               }
+               possible_provider_locations = {
+                 "azure" => [
+                   { "id" => "East US",      "name" => "East US" },
+                   { "id" => "North Europe", "name" => "North Europe" },
+                   { "id" => "West Europe",  "name" => "West Europe" },
+                   { "id" => "West US",      "name" => "West US" },
+                   { "id" => "Japan East",   "name" => "Japan East" }
+                 ],
+                 "aws" => [
+                   { "id" => "us-east-1",      "name" => "Eastern United States" },
+                   { "id" => "us-west-1",      "name" => "Western US (Northern CA)" },
+                   { "id" => "us-west-2",      "name" => "Western US (Oregon)" },
+                   { "id" => "sa-east-1",      "name" => "South America" },
+                   { "id" => "eu-west-1",      "name" => "Europe" },
+                   { "id" => "ap-southeast-1", "name" => "Singapore" },
+                   { "id" => "ap-southeast-2", "name" => "Australia" },
+                   { "id" => "ap-northeast-1", "name" => "Japan" }
+                 ]
+               }
+               {
+                 :account_referrals           => {},
+                 :accounts                    => {},
+                 :addons                      => {},
+                 :addresses                   => {},
+                 :agents                      => {},
+                 :alerts                      => {},
+                 :application_archives        => {},
+                 :application_deployments     => {},
+                 :applications                => {},
+                 :backup_files                => {},
+                 :backups                     => {},
+                 :billing                     => {},
+                 :cluster_firewalls           => [],
+                 :components                  => components,
+                 :contact_assignments         => [],
+                 :contacts                    => {},
+                 :costs                       => [],
+                 :database_plan_usages        => Hash.new { |h1,k1| h1[k1] = {} },
+                 :database_server_firewalls   => [],
+                 :database_server_revisions   => {},
+                 :database_server_snapshots   => {},
+                 :database_server_usages      => Hash.new { |h1,k1| h1[k1] = {} },
+                 :database_servers            => {},
+                 :database_services           => {},
+                 :deleted                     => Hash.new {|x,y| x[y] = {}},
+                 :environment_plan_usages     => Hash.new { |h1,k1| h1[k1] = {} },
+                 :environments                => {},
+                 :features                    => {},
+                 :firewall_rules              => {},
+                 :firewalls                   => {},
+                 :keypair_deployments         => {},
+                 :keypairs                    => {},
+                 :legacy_alerts               => {},
+                 :load_balancer_nodes         => {},
+                 :load_balancer_services      => {},
+                 :load_balancers              => {},
+                 :logical_databases           => {},
+                 :logs                        => {},
+                 :memberships                 => {},
+                 :messages                    => {},
+                 :plan_usages                 => Hash.new { |h1,k1| h1[k1] = {} },
+                 :possible_provider_locations => possible_provider_locations,
+                 :provider_locations          => {},
+                 :providers                   => {},
+                 :requests                    => {},
+                 :server_events               => {},
+                 :server_usages               => Hash.new { |h1,k1| h1[k1] = {} },
+                 :servers                     => {},
+                 :ssl_certificates            => {},
+                 :storage_users               => {},
+                 :storages                    => {},
+                 :support_trials              => {},
+                 :tasks                       => {},
+                 :temp_files                  => {},
+                 :untracked_servers           => {},
+                 :users                       => {},
+                 :volumes                     => {},
+               }
+             end
+    end
+  end
+
+  class << self
+    attr_accessor :delay
+  end
+
+  def self.reset!
+    @data = nil
+    @serial_id = 1
+    @delay = 1
+  end
+
+  def delay
+    self.class.delay
+  end
+
+  def data
+    self.class.data[self.url]
+  end
+
+  attr_reader :current_server
+
+  def initialize(options={})
+    setup(options)
+    @url = options[:url] || "https://api.engineyard.com"
+
+    if authentication == :token
+      if server = self.data[:servers].values.find { |s| s["token"] == options[:token] }
+        @current_server = server
+      else
+        @current_user ||= begin
+                            _,found = self.data[:users].detect{|k,v| v["token"] == options[:token]}
+                            found
+                          end
+
+        # FIXME(rs) get rid of this and the implicit Josh Lane creation entirely
+        @current_user ||= begin
+                            _,found = self.data[:users].detect{|k,v| v["email"] == "jlane@engineyard.com"}
+                            found
+                          end
+
+        unless @current_user
+          user = Ey::Core::Client.new({
+            :url      => @url,
+            :auth_id  => SecureRandom.hex(8),
+            :auth_key => SecureRandom.hex(16),
+          }).users.create!({
+              :email => "jlane@engineyard.com",
+              :name  => "Joshua Lane",
+            })
+
+          if options[:token]
+            self.data[:users][user.id]["token"] = options[:token]
+          end
+
+          @current_user = self.data[:users][user.id]
+        end
+      end
+    end
+  end
+
+  # Lazily re-seeds data after reset
+  # @return [Hash] current user response
+  def current_user
+    if @current_user
+      self.data[:users][@current_user["id"]] ||= @current_user
+
+      @current_user
+    end
+  end
+
+  def response(options={})
+    status  = options[:status] || 200
+    body    = options[:body]
+    headers = {
+      "Content-Type"  => "application/json; charset=utf-8"
+    }.merge(options[:headers] || {})
+
+
+    @logger.debug "MOCKED RESPONSE: #{status}"
+    @logger.debug('response') { headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n") }
+    @logger.debug caller[0]
+    @logger.debug('response.body') { body }
+    @logger.debug ''
+
+    Ey::Core::Response.new(
+      :status  => status,
+      :headers => headers,
+      :body    => body,
+      :request => {
+        :method  => :mocked,
+        :url     => caller[1],
+      }
+    ).raise!
+  end
+
+  def serial_id
+    @@serial_id ||= 0
+    @@serial_id += 1
+  end
+
+  def add_agent(cluster, options={})
+    deis_cluster = find(:deis_clusters, cluster.identity)
+
+    host = options[:host] || self.ip_address
+
+    agent_id = SecureRandom.uuid
+    agent = self.data[:agents][agent_id] = {
+      "id"           => agent_id,
+      "alerts"       => url_for("agents", agent_id, "alerts"),
+      "cluster"      => url_for("deis-clusters", deis_cluster["id"]),
+      "created_at"   => Time.now.to_s,
+      "host"         => host,
+      "last_seen_at" => options.fetch(:last_seen_at, Time.now.to_s),
+      "updated_at"   => Time.now.to_s,
+    }
+
+    self.agents.new(agent)
+  end
+end # Mock

data/lib/ey-core/client/real.rb

@@ -0,0 +1,93 @@
+class Ey::Core::Client::Real
+  include Ey::Core::Client::Shared
+
+  def initialize(options={})
+    setup(options)
+    adapter            = options[:adapter] || Faraday.default_adapter
+    connection_options = options[:connection_options] || {}
+
+    @connection = Faraday.new({url: @url}.merge(connection_options)) do |builder|
+      # response
+      builder.response :json, content_type: /json/
+
+      builder.use Ey::Core::ResponseCache, cache: @cache if @cache
+
+      # request
+      builder.request :multipart
+      builder.request :json
+
+      # request
+      builder.request :retry,
+        :max                 => 5,
+        :interval            => 1,
+        :interval_randomness => 0.05,
+        :backoff_factor      => 2
+
+      unless @authentication == :none
+        if @token
+          builder.use Ey::Core::TokenAuthentication, @token
+        else
+          builder.use :hmac, @auth_id, @auth_key
+        end
+      end
+
+      builder.use Ey::Core::Logger, @logger
+
+      if options[:builder]
+        options[:builder].call(builder)
+      end
+
+      builder.adapter(*adapter)
+    end
+  end
+
+  def request(options={})
+    method  = options[:method] || :get
+    url     = options[:url] || File.join(@url, options[:path] || "/")
+    #@todo query is a band-aid
+    query   = options[:query] || {}
+    params  = query.merge(options[:params] || {})
+    body    = options[:body]
+    headers = options[:headers] || {}
+
+    default_content_type = if !body && !params.empty?
+                             "application/x-www-form-urlencoded"
+                           else
+                             "application/json"
+                           end
+    headers = {
+      "Content-Type" => default_content_type,
+      "Accept"       => accept_type,
+    }.merge(headers)
+
+    response = @connection.send(method) do |req|
+      req.url(url)
+      req.headers.merge!(headers)
+      req.params.merge!(params)
+      req.body = body
+    end
+
+    Ey::Core::Response.new(
+      :status  => response.status,
+      :headers => response.headers,
+      :body    => response.body,
+      :request => {
+        :method  => method,
+        :url     => url,
+        :headers => headers,
+        :body    => body,
+        :params  => params,
+      }
+    ).raise!
+  end
+
+  def accept_type
+    "application/vnd.engineyard.v3+json"
+  end
+
+  def reset!
+    request(method: :post, path: "/client/reset")
+  rescue Ey::Core::Response::NotFound # allow me to test against something real where this route doesn't exist
+    nil
+  end
+end

data/lib/ey-core/collection.rb

@@ -0,0 +1,131 @@
+class Ey::Core::Collection < Cistern::Collection
+  class << self
+    attr_accessor :model_root, :model_request, :collection_root, :collection_request
+  end
+
+  attribute :next_link
+  attribute :prev_link
+  attribute :last_link
+  attribute :total_count, type: :integer
+  attribute :url
+
+  def create!(*args)
+    model = self.new(*args)
+    model.save!
+  end
+
+  def model_root
+    self.class.model_root
+  end
+
+  def model_request
+    self.class.model_request
+  end
+
+  def perform_get(params)
+    connection.send(self.model_request, params).body[self.model_root]
+  end
+
+  def get!(id)
+    if data = perform_get("id" => id)
+      new(data)
+    else
+      nil
+    end
+  end
+
+  def get(id)
+    get!(id)
+  rescue Ey::Core::Response::NotFound
+    nil
+  end
+
+  def collection_root
+    self.class.instance_variable_get(:@collection_root)
+  end
+
+  def collection_request
+    self.class.instance_variable_get(:@collection_request)
+  end
+
+  def next_page
+    new_page.all("url" => self.next_link) if self.next_link
+  end
+
+  def previous_page
+    new_page.all("url" => self.prev_link) if self.prev_link
+  end
+
+  def last_page
+    all("url" => self.last_link)
+  end
+
+  def ==(comparison_object)
+    comparison_object.equal?(self) ||
+      (comparison_object.is_a?(self.class) &&
+       comparison_object.map(&:identity) == self.map(&:identity))
+  end
+
+  def all(params={})
+    params["url"] ||= self.url
+
+    self.load(
+      self.connection.send(self.collection_request, Cistern::Hash.stringify_keys(params))
+    )
+  end
+
+  def first(params={})
+    params.empty? ? super() : all(params).to_a.first
+  end
+
+  # asserts the results contain only a single record and returns it
+  def one
+    if size == 0
+      raise "Could not find any records"
+    elsif size > 1
+      raise "Search returned multiple records when only one was expected"
+    else
+      first
+    end
+  end
+
+  def each_page
+    return to_enum(:each_page) unless block_given?
+    page = self
+    while page
+      yield page
+      page = page.next_page
+    end
+  end
+
+  def each_entry
+    return to_enum(:each_entry) unless block_given?
+    page = self
+    while page
+      page.to_a.each { |r| yield r }
+      page = page.next_page
+    end
+  end
+
+  def page_parameters(response)
+    links = (response.headers['Link'] || "").split(", ").inject({}) do |r, link|
+      value, key = link.match(/<(.*)>; rel="(\w+)"/).captures
+      r.merge("#{key}_link" => value)
+    end
+
+    links.merge(total_count: response.headers['X-Total-Count'])
+  end
+
+  def new_page
+    self.class.new(connection: self.connection)
+  end
+
+  def load(data)
+    if data.is_a?(Ey::Core::Response)
+      self.merge_attributes(page_parameters(data))
+      super(data.body[self.collection_root])
+    else
+      super
+    end
+  end
+end