engineyard 0.2.7

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Engine Yard, Inc
+
+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.rdoc

@@ -0,0 +1,7 @@
+= ey
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2010 Engine Yard. See LICENSE for details.

data/bin/ey

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'engineyard/cli'
+
+begin
+  EY::CLI.start
+rescue EY::Error => e
+  EY.ui.print_exception(e)
+  exit(1)
+rescue Interrupt => e
+  puts
+  EY.ui.print_exception(e)
+  EY.ui.say("Quitting...")
+  exit(1)
+end

data/lib/engineyard.rb

@@ -0,0 +1,44 @@
+module EY
+  VERSION = "0.2.7"
+
+  autoload :Account, 'engineyard/account'
+  autoload :API,     'engineyard/api'
+  autoload :Config,  'engineyard/config'
+  autoload :Repo,    'engineyard/repo'
+
+  class Error < RuntimeError; end
+
+  class UI
+    # stub debug outside of the CLI
+    def debug(*); end
+  end
+
+  class << self
+    attr_accessor :ui
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    def config
+      @config ||= EY::Config.new
+    end
+
+    def config=(config)
+      @config = config
+    end
+
+    def library(libname)
+      begin
+        require libname
+      rescue LoadError
+        unless @tried_rubygems
+          require 'rubygems' rescue LoadError nil
+          @tried_rubygems = true
+          retry
+        end
+      end
+    end
+
+  end
+end

data/lib/engineyard/account.rb

@@ -0,0 +1,78 @@
+module EY
+  class Account
+
+    def initialize(api)
+      @api = api
+    end
+
+    def environments
+      return @environments if @environments
+      data = @api.request('/environments', :method => :get)["environments"]
+      @environments = Environment.from_array(data || [])
+    end
+
+    def environment_named(name)
+      environments.find{|e| e.name == name }
+    end
+
+    def apps
+      return @apps if @apps
+      data  = @api.request('/apps', :method => :get)["apps"]
+      @apps = App.from_array(data || [])
+    end
+
+    def app_named(name)
+      apps.find{|a| a.name == name }
+    end
+
+    def app_for_repo(repo)
+      apps.find{|a| repo.urls.include?(a.repository_url) }
+    end
+
+    # Classes to represent the returned data
+    class Environment < Struct.new(:name, :instances_count, :apps, :app_master, :username)
+      def self.from_hash(hash)
+        new(
+          hash["name"],
+          hash["instances_count"],
+          App.from_array(hash["apps"]),
+          AppMaster.from_hash(hash["app_master"]),
+          hash["ssh_username"]
+        ) if hash && hash != "null"
+      end
+
+      def self.from_array(array)
+        array.map{|n| from_hash(n) } if array && array != "null"
+      end
+
+      def configuration
+        EY.config.environments[self.name]
+      end
+      alias_method :config, :configuration
+    end
+
+    class App < Struct.new(:name, :repository_url, :environments)
+      def self.from_hash(hash)
+        new(
+          hash["name"],
+          hash["repository_uri"], # We use url canonically in the ey gem
+          Environment.from_array(hash["environments"])
+        ) if hash && hash != "null"
+      end
+
+      def self.from_array(array)
+        array.map{|n| from_hash(n) } if array && array != "null"
+      end
+    end
+
+    class AppMaster < Struct.new(:status, :public_hostname)
+      def self.from_hash(hash)
+        new(
+          hash["status"],
+          hash["public_hostname"]
+        ) if hash && hash != "null"
+      end
+    end
+
+  end # Account
+end # EY

data/lib/engineyard/api.rb

@@ -0,0 +1,104 @@
+module EY
+  class API
+    attr_reader :token
+
+    def initialize(token = nil)
+      @token ||= token
+      @token ||= self.class.read_token
+      raise ArgumentError, "EY Cloud API token required" unless @token
+    end
+
+    def ==(other)
+      raise ArgumentError unless other.is_a?(self.class)
+      self.token == other.token
+    end
+
+    def request(url, opts={})
+      opts[:headers] ||= {}
+      opts[:headers]["X-EY-Cloud-Token"] = token
+      EY.ui.debug("Token", token)
+      self.class.request(url, opts)
+    end
+
+    class InvalidCredentials < EY::Error; end
+    class RequestFailed < EY::Error; end
+
+    def self.request(path, opts={})
+      EY.library 'rest_client'
+      EY.library 'json'
+
+      url = EY.config.endpoint + "api/v2#{path}"
+      method = ((meth = opts.delete(:method)) && meth.to_s || "get").downcase.to_sym
+      params = opts.delete(:params) || {}
+      headers = opts.delete(:headers) || {}
+      headers["Accept"] ||= "application/json"
+
+      begin
+        EY.ui.debug("Request", "#{method.to_s.upcase} #{url}")
+        case method
+        when :get, :delete, :head
+          url.query = RestClient::Payload::UrlEncoded.new(params).to_s
+          resp = RestClient.send(method, url.to_s, headers)
+        else
+          resp = RestClient.send(method, url.to_s, params, headers)
+        end
+      rescue RestClient::Unauthorized
+        raise InvalidCredentials
+      rescue Errno::ECONNREFUSED
+        raise RequestFailed, "Could not reach the cloud API"
+      rescue RestClient::ResourceNotFound
+        raise RequestFailed, "The requested resource could not be found"
+      rescue RestClient::RequestFailed => e
+        raise RequestFailed, "#{e.message}"
+      end
+      raise RequestFailed, "Response body was empty" if resp.body.empty?
+
+      begin
+        data = JSON.parse(resp.body)
+        EY.ui.debug("Response", data)
+      rescue JSON::ParserError
+        EY.ui.debug("Raw response", resp.body)
+        raise RequestFailed, "Response was not valid JSON."
+      end
+
+      data
+    end
+
+    def self.fetch_token(email, password)
+      api_token = request("/authenticate", :method => "post",
+        :params => { :email => email, :password => password })["api_token"]
+      save_token(api_token)
+      api_token
+    end
+
+    def self.read_token(file = nil)
+      file ||= ENV['EYRC'] || File.expand_path("~/.eyrc")
+      return false unless File.exists?(file)
+
+      require 'yaml'
+
+      data = YAML.load_file(file)
+      if EY.config.default_endpoint?
+        data["api_token"]
+      else
+        (data[EY.config.endpoint.to_s] || {})["api_token"]
+      end
+    end
+
+    def self.save_token(token, file = nil)
+      file ||= ENV['EYRC'] || File.expand_path("~/.eyrc")
+      require 'yaml'
+
+      data = File.exists?(file) ? YAML.load_file(file) : {}
+      if EY.config.default_endpoint?
+        data.merge!("api_token" => token)
+      else
+        data.merge!(EY.config.endpoint.to_s => {"api_token" => token})
+      end
+
+      File.open(file, "w"){|f| YAML.dump(data, f) }
+      true
+    end
+
+  end # API
+end # EY

data/lib/engineyard/cli.rb

@@ -0,0 +1,169 @@
+$:.unshift File.expand_path('../../vendor', __FILE__)
+require 'thor'
+
+require 'engineyard'
+require 'engineyard/cli/error'
+
+module EY
+  class CLI < Thor
+    EYSD_VERSION = "~>0.2.4.pre1"
+
+    autoload :API, 'engineyard/cli/api'
+    autoload :UI,  'engineyard/cli/ui'
+
+    include Thor::Actions
+
+    def self.start(*)
+      EY.ui = EY::CLI::UI.new
+      super
+    end
+
+    desc "deploy [ENVIRONMENT] [BRANCH]", "Deploy [BRANCH] of the app in the current directory to [ENVIRONMENT]"
+    method_option :force, :type => :boolean, :aliases => %w(-f),
+      :desc => "Force a deploy of the specified branch"
+    method_option :migrate, :type => :string, :aliases => %w(-m),
+      :desc => "Run migrations via [MIGRATE], defaults to 'rake db:migrate'"
+    method_option :install_eysd, :type => :boolean, :aliases => %(-s),
+      :desc => "Force remote install of eysd"
+    def deploy(env_name = nil, branch = nil)
+      app = account.app_for_repo(repo)
+      raise NoAppError.new(repo) unless app
+
+      env_name ||= EY.config.default_environment
+      raise DeployArgumentError if !env_name && app.environments.size != 1
+
+      default_branch = EY.config.default_branch(env_name)
+      branch ||= (default_branch || repo.current_branch)
+      raise DeployArgumentError unless branch
+
+      invalid_branch = default_branch && (branch != default_branch) && !options[:force]
+      raise BranchMismatch.new(default_branch, branch) if invalid_branch
+
+      if env_name
+        env = app.environments.find{|e| e.name == env_name }
+      else
+        env = app.environments.first
+      end
+
+      if !env && account.environment_named(env_name)
+        raise EnvironmentError, "Environment '#{env_name}' doesn't run this application\nYou can add it at #{EY.config.endpoint}"
+      elsif !env
+        raise NoEnvironmentError
+      end
+
+      running = env.app_master && env.app_master.status == "running"
+      raise EnvironmentError, "No running instances for environment #{env.name}\nStart one at #{EY.config.endpoint}" unless running
+
+      hostname = env.app_master.public_hostname
+      username = env.username
+
+      EY.ui.info "Connecting to the server..."
+      ssh_to(hostname, "eysd check '#{EY::VERSION}' '#{EYSD_VERSION}'", username, false)
+      case $?.exitstatus
+      when 255
+        raise EnvironmentError, "SSH connection to #{hostname} failed"
+      when 127
+        EY.ui.warn "Server does not have ey-deploy gem installed"
+        eysd_installed = false
+      when 0
+        eysd_installed = true
+      else
+        raise EnvironmentError, "ey-deploy version not compatible"
+      end
+
+      if !eysd_installed || options[:install_eysd]
+        EY.ui.info "Installing ey-deploy gem..."
+        ssh_to(hostname,
+            "sudo gem install ey-deploy -v '#{EYSD_VERSION}'",
+            username)
+      end
+
+      deploy_cmd = "eysd deploy --app #{app.name} --branch #{branch}"
+      if env.config
+        escaped_config_option = env.config.to_json.gsub(/"/, "\\\"")
+        deploy_cmd << " --config '#{escaped_config_option}'"
+      end
+
+      if options.key(:migrate)
+        if options[:migrate]
+          deploy_cmd << " --migrate='#{options[:migrate]}'"
+        else
+          deploy_cmd << " --no-migrate"
+        end
+      end
+
+      EY.ui.info "Running deploy on server..."
+      deployed = ssh_to(hostname, deploy_cmd, username)
+
+      if deployed
+        EY.ui.info "Deploy complete"
+      else
+        raise EY::Error, "Deploy failed"
+      end
+    end
+
+
+    desc "environments [--all]", "List cloud environments for this app, or all environments"
+    method_option :all, :type => :boolean, :aliases => %(-a)
+    def environments
+      app = account.app_for_repo(repo)
+      if options[:all] || !app
+        envs = account.environments
+        if envs.empty?
+          EY.ui.say %|You do not have any cloud environments.|
+        else
+          EY.ui.say %|Cloud environments:|
+          EY.ui.print_envs(envs, EY.config.default_environment)
+        end
+
+        EY.ui.warn(NoAppError.new(repo).message) unless app || options[:all]
+      else
+        app = account.app_for_repo(repo)
+        envs = app.environments
+        if envs.empty?
+          EY.ui.warn %|You have no environments set up for the application "#{app.name}"|
+          EY.ui.warn %|You can make one at #{EY.config.endpoint}|
+        else
+          EY.ui.say %|Cloud environments for #{app.name}:|
+          EY.ui.print_envs(envs, EY.config.default_environment)
+        end
+      end
+    end
+    map "envs" => :environments
+
+    desc "ssh ENV", "Open an ssh session to the environment's application server"
+    def ssh(name)
+      env = account.environment_named(name)
+      if env
+        Kernel.exec "ssh", "#{env.username}@#{env.app_master.public_hostname}", *ARGV[2..-1]
+      else
+        EY.ui.warn %|Could not find an environment named "#{name}"|
+      end
+    end
+
+    desc "version", "Print the version of the engineyard gem"
+    def version
+      EY.ui.say %{engineyard version #{EY::VERSION}}
+    end
+    map "-v" => :version
+
+  private
+
+    def account
+      @account ||= EY::Account.new(API.new)
+    end
+
+    def repo
+      @repo ||= EY::Repo.new
+    end
+
+    def ssh_to(hostname, remote_cmd, user, output = true)
+      cmd = %{ssh -o StrictHostKeyChecking=no -q #{user}@#{hostname} "#{remote_cmd}"}
+      cmd << %{ &> /dev/null} unless output
+      EY.ui.debug(cmd)
+      puts cmd if output
+      system cmd unless ENV["NO_SSH"]
+    end
+
+  end # CLI
+end # EY

data/lib/engineyard/cli/api.rb

@@ -0,0 +1,42 @@
+module EY
+  class CLI
+    class API < EY::API
+
+      def initialize(token = nil)
+        @token = token
+        @token ||= self.class.read_token
+        @token ||= self.class.fetch_token
+        raise EY::Error, "Sorry, we couldn't get your API token." unless @token
+      end
+
+      def request(*)
+        begin
+          super
+        rescue EY::API::InvalidCredentials
+          EY.ui.warn "Credentials rejected, please authenticate again"
+          refresh
+          retry
+        end
+      end
+
+      def refresh
+        @token = self.class.fetch_token
+      end
+
+      def self.fetch_token
+        EY.ui.warn("The engineyard gem is prerelease software. Please do not use")
+        EY.ui.warn("this tool to deploy to mission-critical environments, yet.")
+        EY.ui.info("We need to fetch your API token, please login")
+        begin
+          email    = EY.ui.ask("Email: ")
+          password = EY.ui.ask("Password: ", true)
+          super(email, password)
+        rescue EY::API::InvalidCredentials
+          EY.ui.warn "Invalid username or password, please try again"
+          retry
+        end
+      end
+
+    end
+  end
+end