ey-core 3.0.0

data/lib/ey-core/associations.rb

@@ -0,0 +1,155 @@
+module Ey::Core::Associations
+  def assoc_coverage(options)
+    if defined? Cistern::Coverage
+      call = Cistern::Coverage.find_caller_before("ey-core/associations.rb")
+
+      if call and call.label.start_with?("<class:")
+        options[:coverage_file] = call.absolute_path
+        options[:coverage_line] = call.lineno
+        options[:coverage_hits] = 0
+      end
+    end
+  end
+
+  def associations
+    @associations ||= {}
+  end
+
+  def assoc_reader(name, options={})
+    assoc_key  = options[:key]        || "#{name}_id"
+    collection = options[:collection] || "#{name}s"
+    resource   = options[:resource]   || name
+    assoc_name = options[:assoc_name] || resource
+
+    # handle polymorphic assocations
+    #
+    # really only used for connector sources, as they may be cluster_components or addons
+    disambiguate = Proc.new do |object, url, index=0|
+      if object.is_a?(Array) && index > (object.size - 1)
+        raise "No matching object found in #{object}"
+      elsif object.is_a?(Array) && url
+        url_pieces = URI.parse(url).path.split("/").map { |piece| piece.gsub(/-|_/,'') } # "/cluster-components/x" => ["clustercomponents", "x"]
+
+        object.find do |model|
+          normalized_model = model.to_s.gsub(/-|_/, '') # [:cluster_components, :addons] => ["clustercomponents", "addons"]
+          url_pieces.find { |piece| piece.include?(normalized_model) }
+        end
+      elsif object.is_a?(Array)
+        object[index]
+      else
+        object
+      end
+    end
+
+    define_method(name) do
+      url = self.send("#{name}_url")
+      id  = send(assoc_key)
+
+      if id || url
+        begin
+          index ||= 0
+          this_resource   = disambiguate[resource, url, index]
+          this_assoc_name = disambiguate[assoc_name, url, index]
+          this_collection = disambiguate[collection, url, index]
+
+          fetched = self.connection.send("get_#{this_assoc_name}", {"id" => id, "url" => url}).body
+        rescue RuntimeError => e
+          if e.message.match(/url needed/i)
+            index += 1
+            retry if index < 3
+          else
+            raise e
+          end
+        rescue Ey::Core::Response::NotFound
+          index += 1
+          index < 3 ? retry : raise
+        end
+
+        unless fetched[this_resource.to_s]
+          raise "Expected a '#{this_resource.to_s}' in '#{fetched.inspect}'"
+        end
+
+        attributes = fetched[this_resource.to_s]
+
+        if self.connection.respond_to?(this_collection)
+          attributes = attributes.merge(collection: self.connection.send(this_collection))
+        end
+
+        self.connection.send(this_assoc_name, attributes)
+      end
+    end
+  end
+
+  def assoc_writer(name, options={})
+    assoc_key = options[:key] || "#{name}_id"
+    url_key   = options[:key] || "#{name}_url"
+
+    attr_accessor assoc_key
+
+    define_method("#{name}=") do |assoc|
+      if assoc.respond_to?(:identity)
+        self.send("#{assoc_key}=", assoc.identity)
+      elsif assoc.is_a?(String) && assoc.match(URI::regexp)
+        self.send("#{url_key}=", assoc)
+      else
+        self.send("#{assoc_key}=", assoc)
+      end
+    end
+  end
+
+  def assoc_accessor(name, options={})
+    assoc_coverage(options)
+
+    if self.associations[name]
+      raise ArgumentError, "#{self.name} association[#{name}] specified more than once"
+    else
+      self.associations[name] = options
+    end
+
+    aliases = Array(options[:aliases] || name.to_s)
+
+    attribute(:"#{name}_url", aliases: aliases, parser: lambda { |v,_| v.is_a?(String) && v })
+
+    assoc_reader(name, options)
+    assoc_writer(name, options)
+  end
+
+  alias has_one assoc_accessor
+
+  def collection_reader(name, options={})
+    assoc_coverage(options)
+
+    if self.associations[name]
+      raise ArgumentError, "#{self.name} association[#{name}] specified more than once"
+    else
+      self.associations[name] = options
+    end
+
+    attribute(:"#{name}_url", aliases: options[:aliases] || [name.to_s])
+
+    assoc_key = options[:key] || name
+    collection_key = options[:model] || assoc_key
+
+    define_method(name) do
+      value = self.send("#{name}_url")
+
+      if self.identity && !value
+        raise "Cannot load #{name} association: #{name}_url is not set"
+      end
+
+      # @fixme this allows collections to be stored in a url variable on create before being replaced
+      # by a url entry after create upon {#merge_attributes}
+      if value.nil?
+        []
+      elsif value.is_a?(String) && value.match(URI::regexp)
+        self.connection.send(collection_key, {"url" => value})
+      elsif value.is_a?(Hash)
+        [value]
+      else
+        Array(value)
+      end
+    end
+  end
+
+  alias has_many collection_reader
+end

data/lib/ey-core/cli.rb

@@ -0,0 +1,118 @@
+require 'optparse'
+require 'ostruct'
+require 'ey-core'
+require 'awesome_print'
+require 'pry'
+
+Cistern.formatter = Cistern::Formatter::AwesomePrint
+
+class Ey::Core::Cli
+
+  def self.stdout
+    @stdout ||= STDOUT
+  end
+
+  def self.say(*args)
+    self.stdout.puts(*args)
+  end
+
+  attr_reader :options, :action, :resource, :client
+
+  def initialize(args=ARGV)
+    @action, @options = parse(args)
+  end
+
+  def parse(args)
+    options = {}
+
+    action, resource_name, resource_id = OptionParser.new do |opts|
+      opts.banner = "Usage: ey-core ACTION RESOURCE RESOURCE_ID [options]"
+
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      opts.on("-t", "--token [TOKEN]",
+              "Use specific token. Defaults to core url entry in ~/.ey-core yaml file") do |token|
+        options[:token] = token
+      end
+
+      opts.on("-u", "--url [URL]",
+              "Use specific core URL. Defaults to 'https://api.engineyard.com'") do |url|
+        options[:url] = url
+      end
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        options[:logger] = v ? Logger.new(STDOUT) : Logger.new(nil)
+      end
+
+      opts.separator ""
+      opts.separator "Common options:"
+
+      # No argument, shows at tail.  This will print an options summary.
+      # Try it and see!
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+
+      # Another typical switch to print the version.
+      opts.on_tail("--version", "Show version") do
+        puts Ey::Core::VERSION
+        exit
+      end
+    end.parse!(args)
+
+    set_client(options)
+
+    set_resource(action, resource_name, resource_id) if resource_name && resource_id
+
+    [action, (options.to_hash || {})]
+  end
+
+  def run
+    public_send(action)
+  end
+
+  def console
+    Pry.config.prompt = proc { |obj, nest_level, _| "ey-core:> " }
+    self.pry
+  end
+
+  def show
+    Ey::Core::Cli.say(resource.ai)
+  end
+
+  def destroy
+    response = resource.destroy!
+
+    if response.is_a?(Ey::Core::Client::Request)
+      response.wait_for!(response.service.timeout, response.service.poll_interval) do |request|
+        Ey::Core::Cli.say "Waiting ... #{Time.now}"
+        Ey::Core::Cli.say(response.ai) unless request.ready?
+        request.ready?
+      end
+    end
+
+    Ey::Core::Cli.say(response.ai)
+  end
+
+  def current_user
+    @current_user ||= @client.users.current
+  end
+
+  def set_client(options)
+    @client ||= Ey::Core::Client.new(options)
+  end
+
+  def set_resource(action, resource_name, resource_id)
+    action = 'show' if action == 'console'
+    action || raise(ArgumentError.new("Missing action"))
+    Ey::Core::Client.models.find { |m,_| m.to_s == resource_name } || raise(ArgumentError.new("Unknown resource: #{resource_name}"))
+    %w[show destroy].include?(action) || raise(ArgumentError.new("Unknown action: #{action}"))
+
+    # TODO: irregular inflections and all that
+    collection = "#{resource_name.to_s}s"
+
+    @resource = client.public_send(collection).get!(resource_id)
+  end
+end  # class Ey::Core::Cli

data/lib/ey-core/client.rb

@@ -0,0 +1,402 @@
+class Ey::Core::Client < Cistern::Service
+  NotPermitted = Class.new(StandardError)
+
+  collection_path "ey-core/collections"
+  model_path      "ey-core/models"
+  request_path    "ey-core/requests"
+
+  collection :account_cancellations
+  collection :account_referrals
+  collection :accounts
+  collection :addons
+  collection :addresses
+  collection :alerts
+  collection :application_archives
+  collection :application_deployments
+  collection :applications
+  collection :backup_files
+  collection :components
+  collection :contacts
+  collection :costs
+  collection :database_plan_usages
+  collection :database_server_revisions
+  collection :database_server_snapshots
+  collection :database_server_usages
+  collection :database_servers
+  collection :database_services
+  collection :environment_plan_usages
+  collection :environments
+  collection :features
+  collection :firewall_rules
+  collection :firewalls
+  collection :gems
+  collection :keypair_deployments
+  collection :keypairs
+  collection :legacy_alerts
+  collection :load_balancer_nodes
+  collection :load_balancer_services
+  collection :load_balancers
+  collection :logical_databases
+  collection :logs
+  collection :memberships
+  collection :messages
+  collection :plan_usages
+  collection :provider_locations
+  collection :providers
+  collection :requests
+  collection :server_events
+  collection :server_usages
+  collection :servers
+  collection :services
+  collection :ssl_certificates
+  collection :storage_users
+  collection :storages
+  collection :tasks
+  collection :tokens
+  collection :untracked_addresses
+  collection :untracked_servers
+  collection :users
+  collection :volumes
+
+  model :account
+  model :account_cancellation
+  model :account_referral
+  model :account_trial
+  model :addon
+  model :address
+  model :alert
+  model :application
+  model :application_archive
+  model :application_deployment
+  model :backup_file
+  model :billing
+  model :component
+  model :contact
+  model :cost
+  model :database_plan_usage
+  model :database_server
+  model :database_server_revision
+  model :database_server_snapshot
+  model :database_server_usage
+  model :database_service
+  model :environment
+  model :environment_plan_usage
+  model :feature
+  model :firewall
+  model :firewall_rule
+  model :gem
+  model :keypair
+  model :keypair_deployment
+  model :legacy_alert
+  model :load_balancer
+  model :load_balancer_node
+  model :load_balancer_service
+  model :log
+  model :logical_database
+  model :membership
+  model :message
+  model :plan_usage
+  model :provider
+  model :provider_location
+  model :request
+  model :server
+  model :server_event
+  model :server_usage
+  model :service
+  model :ssl_certificate
+  model :storage
+  model :storage_user
+  model :support_trial
+  model :task
+  model :token
+  model :untracked_address
+  model :untracked_server
+  model :user
+  model :volume
+
+  request :attach_address
+  request :authorized_channel
+  request :boot_environment
+  request :bootstrap_logical_database
+  request :cancel_account
+  request :create_account
+  request :create_addon
+  request :create_address
+  request :create_alert
+  request :create_application
+  request :create_application_archive
+  request :create_backup_file
+  request :create_database_server
+  request :create_database_service
+  request :create_database_service_snapshot
+  request :create_environment
+  request :create_firewall
+  request :create_firewall_rule
+  request :create_keypair
+  request :create_keypair_deployment
+  request :create_load_balancer
+  request :create_log
+  request :create_logical_database
+  request :create_membership
+  request :create_message
+  request :create_password_reset
+  request :create_provider
+  request :create_ssl_certificate
+  request :create_storage
+  request :create_storage_user
+  request :create_task
+  request :create_token
+  request :create_untracked_address
+  request :create_untracked_server
+  request :create_user
+  request :deploy_environment_application
+  request :deprovision_environment
+  request :destroy_addon
+  request :destroy_database_server
+  request :destroy_database_server_snapshot
+  request :destroy_database_service
+  request :destroy_environment
+  request :destroy_firewall
+  request :destroy_firewall_rule
+  request :destroy_load_balancer
+  request :destroy_logical_database
+  request :destroy_provider
+  request :destroy_server
+  request :destroy_ssl_certificate
+  request :destroy_storage
+  request :destroy_storage_user
+  request :destroy_user
+  request :detach_address
+  request :disable_feature
+  request :discover_database_server
+  request :discover_database_server_snapshots
+  request :discover_provider_location
+  request :download_file
+  request :enable_feature
+  request :get_account
+  request :get_account_cancellation
+  request :get_account_referrals
+  request :get_account_trial
+  request :get_accounts
+  request :get_addon
+  request :get_addons
+  request :get_address
+  request :get_addresses
+  request :get_alert
+  request :get_alerting_environments
+  request :get_alerts
+  request :get_api_token
+  request :get_application
+  request :get_application_archive
+  request :get_application_archives
+  request :get_application_deployment
+  request :get_application_deployments
+  request :get_applications
+  request :get_backup_file
+  request :get_backup_files
+  request :get_billing
+  request :get_component
+  request :get_components
+  request :get_contacts
+  request :get_costs
+  request :get_current_user
+  request :get_database_plan_usages
+  request :get_database_server
+  request :get_database_server_revisions
+  request :get_database_server_snapshot
+  request :get_database_server_snapshots
+  request :get_database_server_usages
+  request :get_database_servers
+  request :get_database_servers_firewalls
+  request :get_database_service
+  request :get_database_services
+  request :get_environment
+  request :get_environment_database_services
+  request :get_environment_logical_databases
+  request :get_environment_plan_usages
+  request :get_environments
+  request :get_feature
+  request :get_features
+  request :get_firewall
+  request :get_firewall_rule
+  request :get_firewall_rules
+  request :get_firewalls
+  request :get_gem
+  request :get_keypair
+  request :get_keypair_deployment
+  request :get_keypair_deployments
+  request :get_keypairs
+  request :get_legacy_alert
+  request :get_legacy_alerts
+  request :get_load_balancer
+  request :get_load_balancer_node
+  request :get_load_balancer_nodes
+  request :get_load_balancer_service
+  request :get_load_balancer_services
+  request :get_load_balancers
+  request :get_log
+  request :get_logical_database
+  request :get_logical_databases
+  request :get_logs
+  request :get_membership
+  request :get_message
+  request :get_messages
+  request :get_metadata
+  request :get_plan_usages
+  request :get_possible_provider_locations
+  request :get_provider
+  request :get_provider_location
+  request :get_provider_locations
+  request :get_providers
+  request :get_request
+  request :get_requests
+  request :get_server
+  request :get_server_event
+  request :get_server_events
+  request :get_server_usages
+  request :get_servers
+  request :get_ssl_certificate
+  request :get_ssl_certificates
+  request :get_storage
+  request :get_storage_user
+  request :get_storage_users
+  request :get_storages
+  request :get_support_trial
+  request :get_task
+  request :get_tasks
+  request :get_untracked_server
+  request :get_untracked_servers
+  request :get_user
+  request :get_users
+  request :get_volumes
+  request :reboot_server
+  request :request_callback
+  request :reset_password
+  request :run_cluster_application_action
+  request :run_environment_application_action
+  request :signup
+  request :update_addon
+  request :update_address
+  request :update_alert
+  request :update_application_archive
+  request :update_billing
+  request :update_membership
+  request :update_server
+  request :update_ssl_certificate
+  request :update_untracked_server
+  request :upload_file
+
+  recognizes :token, :url, :logger, :adapter, :builder, :connection_options, :auth_id, :auth_key, :cache, :config_file
+
+  module Shared
+    attr_reader :authentication, :url, :cache
+
+    def setup(options)
+      token_dotfile = begin
+                        if options[:config_file]
+                          YAML.load_file(options[:config_file]) || {} # if the file is empty, yaml returns false
+                        else
+                          YAML.load_file(File.expand_path("~/.ey-core"))
+                        end
+                      rescue Errno::ENOENT
+                        {}
+                      end
+
+      resolved_url = options[:url] || ENV["CORE_URL"] || "https://api.engineyard.com/"
+      @url   = File.join(resolved_url, "/") # trailing slash # consistency # hash tag you're welcome
+      @cache = if options[:cache] == true
+                 Ey::Core::MemoryCache
+               else options[:cache]
+               end
+
+      @authentication = nil
+      @token = if options.has_key?(:token) && options[:token].nil?
+                 @authentication = :none
+               else
+                 options[:token] || token_dotfile[@url] || token_dotfile[@url.gsub(/\/$/, "")] # matching with or without trailing slash
+               end
+
+      # For HMAC
+      @auth_id  = options[:auth_id]
+      @auth_key = options[:auth_key]
+
+      unless @authentication == :none
+        if !@auth_id && !@auth_key && !@token
+          raise "Missing token. Use Ey::Core::Client.new(token: mytoken) or add \"'#{@url}': mytoken\" to your ~/.ey-core file" unless @token
+        elsif options[:token] || (@token && !@auth_id) # token was explicitly provided
+          @authentication = :token
+        else
+          @authentication = :hmac
+          @token = nil
+        end
+      end
+
+      @logger = options[:logger] || Logger.new(nil)
+    end
+
+    # strong parameter emulation
+    def require_parameters(_params, *_requirements)
+      params       = Cistern::Hash.stringify_keys(_params)
+      requirements = _requirements.map(&:to_s)
+
+      requirements.each do |requirement|
+        unless !params[requirement].nil?
+          if self.class == Ey::Core::Client::Real
+            raise ArgumentError, "param is missing or the value is empty: #{requirement}"
+          else
+            response(
+              :status => 400,
+              :body   => "param is missing or the value is empty: #{requirement}")
+          end
+        end
+      end
+      values = params.values_at(*requirements)
+      values.size == 1 ? values.first : values
+    end
+
+    def require_arguments(_params, *_requirements)
+      params       = Cistern::Hash.stringify_keys(_params)
+      requirements = _requirements.map(&:to_s)
+
+      values = requirements.map do |requirement|
+        if params[requirement].nil?
+          raise ArgumentError, "argument is missing or the value is empty: #{requirement}"
+        end
+        params[requirement]
+      end
+      [params, *values]
+    end
+
+    def require_argument(_params, *_requirements)
+      params       = Cistern::Hash.stringify_keys(_params)
+      requirements = _requirements.map(&:to_s)
+
+      values = params.values_at(*requirements)
+      values.all?(&:nil?) && raise(ArgumentError.new("argument is missing or the value is empty: #{requirement}"))
+      values.size == 1 ? values.first : values
+    end
+
+    def require_argument!(_params, *_requirements)
+      params       = Cistern::Hash.stringify_keys(_params)
+      requirements = _requirements.map(&:to_s)
+
+      values = params.values_at(*requirements)
+      values.all?(&:nil?) && raise(ArgumentError.new("argument is missing or the value is empty: #{requirement}"))
+      requirements.each { |r| params.delete(r) }
+      values.size == 1 ? values.first : values
+    end
+
+    def url_for(*args)
+      File.join(@url.to_s, *args.map(&:to_s))
+    end
+
+    # @deprecated will be removed in 3.x
+    # @see {#services}
+    def metadata
+      services.get("core")
+    end
+  end
+end # Ey::Core::Client
+
+require 'ey-core/client/real'
+require 'ey-core/client/mock'