engineyard 0.2.11 → 0.2.12

data/lib/engineyard.rb

@@ -1,13 +1,14 @@
 module EY
-  VERSION = "0.2.11"
+  require 'engineyard/ruby_ext'
+
+  VERSION = "0.2.12"
 
   autoload :Account, 'engineyard/account'
   autoload :API,     'engineyard/api'
   autoload :Config,  'engineyard/config'
+  autoload :Error,   'engineyard/error'
   autoload :Repo,    'engineyard/repo'
 
-  class Error < RuntimeError; end
-
   class UI
     # stub debug outside of the CLI
     def debug(*); end

data/lib/engineyard/#repo.rb#

@@ -0,0 +1,24 @@
+module EY
+  class Repo
+
+    def initialize(path=File.expand_path('.'))
+      @path = path
+    end
+
+    def current_branch
+      head = File.read(File.join(@path, ".git/HEAD")).chomp
+      if head.gsub!("ref: refs/heads/", "")
+        head
+      else
+        nil
+      end
+    end
+
+    def urls
+      `git config -f #{@path}/.git/config --get-regexp 'remote.*.url'`.split(/\n/).map do |c|
+        c.split.last
+      end
+    end
+
+  end # Repo
+end # EY

data/lib/engineyard/account.rb

@@ -1,7 +1,9 @@
+require 'engineyard/account/api_struct'
 require 'engineyard/account/app'
 require 'engineyard/account/app_master'
 require 'engineyard/account/environment'
 require 'engineyard/account/log'
+require 'engineyard/account/instance'
 
 module EY
   class Account
@@ -10,24 +12,43 @@ module EY
       @api = api
     end
 
-    def request(path, options = { })
-      @api.request(path, {:method => :get}.merge(options))
+    def environments
+      @environments ||= begin
+        data = @api.request('/environments')["environments"]
+        Environment.from_array(data, self)
+      end
     end
 
-    def environments
-      return @environments if @environments
-      data = request('/environments')["environments"]
-      @environments = Environment.from_array(data || [], self)
+    def apps
+      @apps ||= App.from_array(@api.request('/apps')["apps"], self)
     end
 
     def environment_named(name)
       environments.find{|e| e.name == name }
     end
 
-    def apps
-      return @apps if @apps
-      data  = @api.request('/apps')["apps"]
-      @apps = App.from_array(data || [], self)
+    def logs_for(env)
+      data = @api.request("/environments/#{env.id}/logs")["logs"]
+      Log.from_array(data)
+    end
+
+    def instances_for(env)
+      @instances ||= begin
+        data = @api.request("/environments/#{env.id}/instances")["instances"]
+        Instance.from_array(data)
+      end
+    end
+
+    def upload_recipes_for(env)
+      @api.request("/environments/#{env.id}/recipes",
+        :method => :post,
+        :params => {:file => env.recipe_file}
+      )
+    end
+
+    def rebuild(env)
+      @api.request("/environments/#{env.id}/rebuild",
+        :method => :put)
     end
 
     def app_named(name)
@@ -35,7 +56,7 @@ module EY
     end
 
     def app_for_repo(repo)
-      apps.find{|a| repo.urls.include?(a.repository_url) }
+      apps.find{|a| repo.urls.include?(a.repository_uri) }
     end
 
   end # Account

data/lib/engineyard/account/api_struct.rb

@@ -0,0 +1,25 @@
+module EY
+  class Account
+    class ApiStruct < Struct
+      def self.new(*args, &block)
+        super(*args) do |*block_args|
+          block.call(*block_args) if block
+
+          def self.from_array(array, account = nil)
+            array.map do |values|
+              from_hash(values.merge(:account => account))
+            end if array
+          end
+
+          def self.from_hash(hash)
+            return nil unless hash
+            members = new.members
+            values = members.map{|a| hash.has_key?(a.to_sym) ? hash[a.to_sym] : hash[a] }
+            new(*values)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/engineyard/account/app.rb

@@ -1,18 +1,19 @@
 module EY
   class Account
-    class App < Struct.new(:name, :repository_url, :environments, :account)
-      def self.from_hash(hash, account)
-        new(
-          hash["name"],
-          hash["repository_uri"], # We use url canonically in the ey gem
-          Environment.from_array(hash["environments"], account),
-          account
-        ) if hash && hash != "null"
+    class App < ApiStruct.new(:name, :repository_uri, :environments, :account)
+
+      def self.from_hash(hash)
+        super.tap do |app|
+          app.environments = Environment.from_array(app.environments, app.account)
+        end
       end
 
-      def self.from_array(array, account)
-        array.map{|n| from_hash(n, account) } if array && array != "null"
+      def one_and_only_environment
+        if environments.size == 1
+          environments.first
+        end
       end
+
     end
   end
 end

data/lib/engineyard/account/app_master.rb

@@ -1,12 +1,6 @@
 module EY
   class Account
-    class AppMaster < Struct.new(:status, :public_hostname)
-      def self.from_hash(hash)
-        new(
-          hash["status"],
-          hash["public_hostname"]
-        ) if hash && hash != "null"
-      end
+    class AppMaster < ApiStruct.new(:status, :public_hostname)
     end
   end
 end

data/lib/engineyard/account/environment.rb

@@ -1,25 +1,40 @@
 module EY
   class Account
-    class Environment < Struct.new(:id, :name, :instances_count, :apps, :app_master, :username, :account)
-      def self.from_hash(hash, account)
-        new(
-          hash["id"],
-          hash["name"],
-          hash["instances_count"],
-          App.from_array(hash["apps"], account),
-          AppMaster.from_hash(hash["app_master"]),
-          hash["ssh_username"],
-          account
-        ) if hash && hash != "null"
+    class Environment < ApiStruct.new(:id, :name, :instances_count, :apps, :app_master, :username, :account)
+      def self.from_hash(hash)
+        super.tap do |env|
+          env.username = hash['ssh_username']
+          env.apps = App.from_array(env.apps, env.account)
+          env.app_master = AppMaster.from_hash(env.app_master)
+        end
       end
 
-      def self.from_array(array, account)
-        array.map{|n| from_hash(n, account) } if array && array != "null"
+      def logs
+        account.logs_for(self)
       end
 
-      def logs
-        data = account.request("/environments/#{id}/logs")['logs']
-        Log.from_array(data || [])
+      def instances
+        account.instances_for(self)
+      end
+
+      def rebuild
+        account.rebuild(self)
+      end
+
+      def recipe_file
+        require 'tempfile'
+        unless File.exist?("cookbooks")
+          raise EY::Error, "Could not find chef recipes. Please run from the root of your recipes repo."
+        end
+
+        tmp = Tempfile.new("recipes")
+        cmd = "git archive --format=tar HEAD cookbooks | gzip > #{tmp.path}"
+
+        unless system(cmd)
+          raise EY::Error, "Could not archive recipes.\nCommand `#{cmd}` exited with an error."
+        end
+
+        tmp
       end
 
       def configuration

data/lib/engineyard/account/instance.rb

@@ -0,0 +1,6 @@
+module EY
+  class Account
+    class Instance < ApiStruct.new(:id, :role, :amazon_id, :public_hostname)
+    end
+  end
+end

data/lib/engineyard/account/log.rb

@@ -1,18 +1,9 @@
-class Log < Struct.new(:id, :role, :main, :custom)
-  def self.from_hash(hash)
-    new(
-      hash["id"],
-      hash["role"],
-      hash["main"],
-      hash["custom"]
-    ) if hash && hash != "null"
-  end
-
-  def self.from_array(array)
-    array.map{|n| from_hash(n) } if array && array != "null"
-  end
-
-  def instance_name
-    "#{role} #{id}"
+module EY
+  class Account
+    class Log < ApiStruct.new(:id, :role, :main, :custom)
+      def instance_name
+        "#{role} #{id}"
+      end
+    end
   end
 end

data/lib/engineyard/action/deploy.rb

@@ -0,0 +1,138 @@
+require 'engineyard/action/util'
+
+module EY
+  module Action
+    class Deploy
+      extend Util
+
+      EYSD_VERSION = "~>0.2.7"
+
+      def self.call(env_name, branch, options)
+        env_name ||= EY.config.default_environment
+
+        app = fetch_app
+        env = fetch_environment(env_name, app)
+        branch = fetch_branch(env.name, branch, options[:force])
+
+        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..."
+        ensure_eysd_present(hostname, username, options[:install_eysd])
+
+        deploy_cmd = "#{eysd_path} 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['migrate']
+          deploy_cmd << " --migrate='#{options[:migrate]}'"
+        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
+
+    private
+
+      def self.fetch_app
+        app = account.app_for_repo(repo)
+        raise NoAppError.new(repo) unless app
+        app
+      end
+
+      def self.fetch_environment(env_name, app)
+        # if the name's not specified and there's not exactly one
+        # environment, we can't figure out which environment to deploy
+        raise DeployArgumentError if !env_name && app.environments.size != 1
+
+        env = if env_name
+                # environment names are unique per-customer, so
+                # there's no danger of finding two here
+                app.environments.find{|e| e.name == env_name }
+              else
+                app.environments.first
+              end
+
+        # the environment exists, but doesn't have this app
+        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}"
+        end
+
+        if !env
+          raise NoEnvironmentError.new(env_name)
+        end
+
+        env
+      end
+
+      def self.fetch_branch(env_name, user_specified_branch, force)
+        default_branch = EY.config.default_branch(env_name)
+
+        branch = if user_specified_branch
+                   if default_branch && (user_specified_branch != default_branch) && !force
+                     raise BranchMismatch.new(default_branch, user_specified_branch)
+                   end
+                   user_specified_branch
+                 else
+                   default_branch || repo.current_branch
+                 end
+
+        raise DeployArgumentError unless branch
+        branch
+      end
+
+      def self.ensure_eysd_present(hostname, username, install_eysd)
+        ssh_to(hostname, "#{eysd_path} 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 || install_eysd
+          EY.ui.info "Installing ey-deploy gem..."
+          ssh_to(hostname,
+            "sudo #{gem_path} install ey-deploy -v '#{EYSD_VERSION}'",
+            username)
+        end
+      end
+
+      def self.eysd_path
+        "/usr/local/ey_resin/ruby/bin/eysd"
+      end
+
+      def self.gem_path
+        "/usr/local/ey_resin/ruby/bin/gem"
+      end
+
+      def self.ssh_to(hostname, remote_cmd, user, output = true)
+        cmd = %{ssh -o StrictHostKeyChecking=no -q #{user}@#{hostname} "#{remote_cmd}"}
+        cmd << %{ &> /dev/null} unless output
+        output ? puts(cmd) : EY.ui.debug(cmd)
+        unless ENV["NO_SSH"]
+          system cmd
+        else
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard/action/list_environments.rb

@@ -0,0 +1,22 @@
+require 'engineyard/action/util'
+
+module EY
+  module Action
+    class ListEnvironments
+      extend Util
+
+      def self.call(all)
+        app, envs = app_and_envs(all)
+        if app
+          EY.ui.say %|Cloud environments for #{app.name}:|
+            EY.ui.print_envs(envs, EY.config.default_environment)
+        elsif envs
+          EY.ui.say %|Cloud environments:|
+            EY.ui.print_envs(envs, EY.config.default_environment)
+        else
+          EY.ui.say %|You do not have any cloud environments.|
+        end
+      end
+    end
+  end
+end

data/lib/engineyard/action/rebuild.rb

@@ -0,0 +1,31 @@
+require 'engineyard/action/util'
+
+module EY
+  module Action
+    class Rebuild
+      extend Util
+
+      def self.call(name)
+        env = fetch_environment_by_name(name) || fetch_environment_from_app
+        EY.ui.debug("Rebuilding #{env.name}")
+        env.rebuild
+      end
+
+      private
+      def self.fetch_environment_by_name(name)
+        if name
+          env = account.environment_named(name)
+          return env if env
+          raise NoEnvironmentError.new(name)
+        end
+      end
+
+      def self.fetch_environment_from_app
+        repo = Repo.new
+        app = account.app_for_repo(repo) or raise NoAppError.new(repo)
+        env = app.one_and_only_environment or raise EnvironmentError, "Unable to determine a single environment for the current application (found #{app.environments.size} environments)"
+        env
+      end
+    end
+  end
+end