engineyard 1.4.29 → 1.7.0.pre2

data/lib/engineyard/model/account.rb

@@ -1,8 +0,0 @@
-require 'escape'
-
-module EY
-  module Model
-    class Account < ApiStruct.new(:id, :name)
-    end
-  end
-end

data/lib/engineyard/model/api_struct.rb

@@ -1,33 +0,0 @@
-module EY
-  module Model
-    class ApiStruct < Struct
-
-      def self.new(*args, &block)
-        super(*args) do |*block_args|
-          block.call(*block_args) if block
-
-          def self.from_array(array, common_values = {})
-            array.map do |values|
-              from_hash(values.merge(common_values))
-            end if array
-          end
-
-          def self.from_hash(hash)
-            return nil unless hash
-            # in ruby 1.8, #members is an array of strings
-            # in ruby 1.9, #members is an array of symbols
-            members = new.members.map {|m| m.to_sym}
-            values = members.map{|a| hash.has_key?(a) ? hash[a] : hash[a.to_s] }
-            new(*values)
-          end
-
-        end
-      end
-
-      def api_get(uri, options = {})
-        api.request(uri, options.merge(:method => :get))
-      end
-
-    end
-  end
-end

data/lib/engineyard/model/app.rb

@@ -1,32 +0,0 @@
-module EY
-  module Model
-    class App < ApiStruct.new(:id, :account, :name, :repository_uri, :environments, :api)
-
-      def self.from_hash(hash)
-        super.tap do |app|
-          app.environments = Environment.from_array(app.environments, :api => app.api)
-          app.account = Account.from_hash(app.account)
-        end
-      end
-
-      def self.from_array(*)
-        Collection::Apps.new(super)
-      end
-
-      def sole_environment
-        if environments.size == 1
-          environments.first
-        end
-      end
-
-      def sole_environment!
-        sole_environment or raise NoSingleEnvironmentError.new(self)
-      end
-
-      def last_deployment_on(environment)
-        Deployment.last(self, environment, api)
-      end
-
-    end
-  end
-end

data/lib/engineyard/model/deployment.rb

@@ -1,90 +0,0 @@
-require 'escape'
-
-module EY
-  module Model
-    class Deployment < ApiStruct.new(:id, :app, :created_at, :commit, :environment, :finished_at, :migrate_command, :output, :ref, :resolved_ref, :successful, :user_name)
-      def self.api_root(app_id, environment_id)
-        "/apps/#{app_id}/environments/#{environment_id}/deployments"
-      end
-
-      def self.last(app, environment, api)
-        get(app, environment, 'last', api)
-      end
-
-      def self.get(app, environment, id, api)
-        response = api.request(api_root(app.id, environment.id) + "/#{id}", :method => :get)
-        load_from_response app, environment, response
-      rescue EY::API::ResourceNotFound
-        nil
-      end
-
-      def self.load_from_response(app, environment, response)
-        dep = new
-        dep.app = app
-        dep.environment = environment
-        dep.update_with_response(response)
-        dep
-      end
-
-      def self.started(environment, app, ref, migrate_command)
-        deployment = from_hash({
-          :app             => app,
-          :environment     => environment,
-          :migrate_command => migrate_command,
-          :ref             => ref,
-        })
-        deployment.start
-        deployment
-      end
-
-      def migrate
-        !!migrate_command
-      end
-
-      alias successful? successful
-
-      def start
-        post_to_api({
-          :migrate         => migrate,
-          :migrate_command => migrate_command,
-          :output          => output,
-          :ref             => ref,
-        })
-      end
-
-      def finished(successful, output)
-        self.successful = successful
-        self.output = output
-        put_to_api({:successful => successful, :output => output})
-      end
-
-      def update_with_response(response)
-        response['deployment'].each do |key,val|
-          send("#{key}=", val) if respond_to?("#{key}=")
-        end
-      end
-
-      private
-
-      def post_to_api(params)
-        update_with_response api.request(collection_uri, :method => :post, :params => {:deployment => params})
-      end
-
-      def put_to_api(params)
-        update_with_response api.request(member_uri("/finished"), :method => :put, :params => {:deployment => params})
-      end
-
-      def collection_uri
-        self.class.api_root(app.id, environment.id)
-      end
-
-      def member_uri(path = nil)
-        collection_uri + "/#{id}#{path}"
-      end
-
-      def api
-        app.api
-      end
-    end
-  end
-end

data/lib/engineyard/model/environment.rb

@@ -1,194 +0,0 @@
-module EY
-  module Model
-    class Environment < ApiStruct.new(:id, :account, :name, :framework_env, :instances, :instances_count,
-                                      :apps, :app_master, :username, :app_server_stack_name, :deployment_configurations,
-                                      :load_balancer_ip_address, :api)
-      require 'launchy'
-
-      attr_accessor :ignore_bad_master
-
-      def self.from_hash(hash)
-        super.tap do |env|
-          env.username = hash['ssh_username']
-          env.apps = App.from_array(env.apps, :api => env.api)
-          env.account = Account.from_hash(env.account)
-          env.instances = Instance.from_array(hash['instances'], :environment => env)
-          env.app_master = Instance.from_hash(env.app_master.merge(:environment => env)) if env.app_master
-        end
-      end
-
-      def self.from_array(*)
-        Collection::Environments.new(super)
-      end
-
-      def logs
-        Log.from_array(api_get("/environments/#{id}/logs")["logs"])
-      end
-
-      def app_master!
-        master = app_master
-        if master.nil?
-          raise NoAppMasterError.new(name)
-        elsif !ignore_bad_master && master.status != "running"
-          raise BadAppMasterStatusError.new(master.status)
-        end
-        master
-      end
-
-      def deploy(app, ref, deploy_options={})
-        app_master!.deploy(app,
-          ref,
-          migration_command(app, deploy_options),
-          config.merge(deploy_options['extras']),
-          deploy_options['verbose'])
-      end
-
-      def rollback(app, extra_deploy_hook_options={}, verbose=false)
-        app_master!.rollback(app,
-          config.merge(extra_deploy_hook_options),
-          verbose)
-      end
-
-      def take_down_maintenance_page(app, verbose=false)
-        app_master!.take_down_maintenance_page(app, verbose)
-      end
-
-      def put_up_maintenance_page(app, verbose=false)
-        app_master!.put_up_maintenance_page(app, verbose)
-      end
-
-      def rebuild
-        api.request("/environments/#{id}/update_instances", :method => :put)
-      end
-
-      def run_custom_recipes
-        api.request("/environments/#{id}/run_custom_recipes", :method => :put)
-      end
-
-      def download_recipes
-        if File.exist?('cookbooks')
-          raise EY::Error, "Could not download, cookbooks already exists"
-        end
-
-        require 'tempfile'
-        tmp = Tempfile.new("recipes")
-        tmp.write(api.request("/environments/#{id}/recipes"))
-        tmp.flush
-        tmp.close
-
-        cmd = "tar xzf '#{tmp.path}' cookbooks"
-
-        unless system(cmd)
-          raise EY::Error, "Could not unarchive recipes.\nCommand `#{cmd}` exited with an error."
-        end
-      end
-
-      def upload_recipes_at_path(recipes_path)
-        recipes_path = Pathname.new(recipes_path)
-        if recipes_path.exist?
-          upload_recipes recipes_path.open('rb')
-        else
-          raise EY::Error, "Recipes file not found: #{recipes_path}"
-        end
-      end
-
-      def tar_and_upload_recipes_in_cookbooks_dir
-        require 'tempfile'
-        unless File.exist?("cookbooks")
-          raise EY::Error, "Could not find chef recipes. Please run from the root of your recipes repo."
-        end
-
-        recipes_file = Tempfile.new("recipes")
-        cmd = "tar czf '#{recipes_file.path}' cookbooks/"
-
-        unless system(cmd)
-          raise EY::Error, "Could not archive recipes.\nCommand `#{cmd}` exited with an error."
-        end
-
-        upload_recipes(recipes_file)
-      end
-
-      def upload_recipes(file_to_upload)
-        api.request("/environments/#{id}/recipes", {
-          :method => :post,
-          :params => {:file => file_to_upload}
-        })
-      end
-
-      # If force_ref is a string, use it as the ref, otherwise use it as a boolean.
-      def resolve_branch(ref, force_ref=false)
-        if String === force_ref
-          ref, force_ref = force_ref, true
-        end
-
-        if !ref
-          default_branch
-        elsif force_ref || !default_branch || ref == default_branch
-          ref
-        else
-          raise BranchMismatchError.new(default_branch, ref)
-        end
-      end
-
-      def configuration
-        EY.config.environments[self.name] || {}
-      end
-      alias_method :config, :configuration
-
-      def default_branch
-        EY.config.default_branch(name)
-      end
-
-      def shorten_name_for(app)
-        name.gsub(/^#{Regexp.quote(app.name)}_/, '')
-      end
-
-      def launch
-        Launchy.open(app_master!.hostname_url)
-      end
-
-      def migration_command(app, deploy_options)
-        # regarding deploy_options['migrate']:
-        #
-        # missing means migrate how the yaml file says to
-        # nil means don't migrate
-        # true means migrate w/custom command (if present) or default
-        # a string means migrate with this specific command
-        return nil if no_migrate?(deploy_options)
-        command = migration_command_from_command_line(deploy_options)
-        unless command
-          return nil if no_migrate?(config)
-          command = migration_command_from_config
-        end
-        command = migration_command_from_environment(app) unless command
-        command
-      end
-
-      private
-
-      def no_migrate?(hash)
-        hash.key?('migrate') && hash['migrate'] == false
-      end
-
-      def migration_command_from_config
-        config['migration_command'] if config['migrate'] || config['migration_command']
-      end
-
-      def migration_command_from_command_line(deploy_options)
-        if migrate = deploy_options['migrate']
-          migrate.respond_to?(:to_str) ? migrate.to_str : (config['migration_command'] || default_migration_command)
-        end
-      end
-
-      def migration_command_from_environment(app)
-        if deploy_config = deployment_configurations[app.name]
-          deploy_config['migrate']['command'] if deploy_config['migrate']['perform']
-        end
-      end
-
-      def default_migration_command
-        'rake db:migrate'
-      end
-    end
-  end
-end

data/lib/engineyard/model/instance.rb

@@ -1,166 +0,0 @@
-require 'escape'
-require 'net/ssh'
-
-module EY
-  module Model
-    class Instance < ApiStruct.new(:id, :role, :name, :status, :amazon_id, :public_hostname, :environment)
-      alias :hostname :public_hostname
-
-      def adapter(app, verbose)
-        require 'engineyard-serverside-adapter'
-        EY::Serverside::Adapter.new("/usr/local/ey_resin/ruby/bin") do |args|
-          args.app           = app.name
-          args.repo          = app.repository_uri
-          args.instances     = instances_data
-          args.verbose       = verbose || ENV['DEBUG']
-          args.stack         = environment.app_server_stack_name
-          args.framework_env = environment.framework_env
-        end
-      end
-      private :adapter
-
-      def deploy(app, ref, migration_command=nil, extra_configuration=nil, verbose=false)
-        successful, output = false, "Deploy initiated.\n"
-        deployment = Deployment.started(environment, app, ref, migration_command)
-
-        deploy_command = adapter(app, verbose).deploy do |args|
-          args.config  = extra_configuration if extra_configuration
-          args.migrate = migration_command if migration_command
-          args.ref     = deployment.resolved_ref
-        end
-
-        successful = invoke(deploy_command) { |chunk| output << chunk }
-      rescue Interrupt
-        output << "Interrupted. Deployment halted.\n"
-        EY.ui.warn "Interrupted."
-        EY.ui.warn "Recording canceled deployment and exiting..."
-        EY.ui.warn "WARNING: Interrupting again may result in a never-finished deployment in the deployment history on EY Cloud."
-        raise
-      rescue StandardError => e
-        EY.ui.info "Error encountered during deploy."
-        output <<  "Error encountered during deploy.\n#{e.class} #{e}\n"
-        raise
-      ensure
-        if deployment
-          deployment.finished(successful, output)
-          EY.ui.info "#{successful ? 'Successful' : 'Failed'} deployment recorded in EY Cloud"
-        end
-      end
-
-      def rollback(app, extra_configuration=nil, verbose=false)
-        rollback = adapter(app, verbose).rollback do |args|
-          args.config = extra_configuration if extra_configuration
-        end
-        invoke rollback
-      end
-
-      def put_up_maintenance_page(app, verbose=false)
-        invoke adapter(app, verbose).enable_maintenance_page
-      end
-
-      def take_down_maintenance_page(app, verbose=false)
-        invoke adapter(app, verbose).disable_maintenance_page
-      end
-
-      def has_app_code?
-        !["db_master", "db_slave"].include?(role.to_s)
-      end
-
-      def hostname_url
-        "http://#{hostname}" if hostname
-      end
-
-    protected
-
-      def engineyard_serverside_hostname
-        # If we tell engineyard-serverside to use 'localhost', it'll run
-        # commands on the instance directly (#system). If we give it the
-        # instance's actual hostname, it'll SSH to itself.
-        #
-        # Using 'localhost' instead of its EC2 hostname speeds up
-        # deploys on solos and single-app-server clusters significantly.
-        app_master? ? 'localhost' : hostname
-      end
-
-    private
-
-      def ssh(remote_command, verbose, &block)
-        raise(ArgumentError, "Block required!") unless block
-
-        exit_code = nil
-        cmd = Escape.shell_command(['bash', '-lc', remote_command])
-        block.call("Running command on #{environment.username}@#{hostname}.\n")
-        if cmd.respond_to?(:encoding) && cmd.respond_to?(:force_encoding)
-          block.call("Encoding: #{cmd.encoding.name}") if verbose
-          cmd.force_encoding('binary')
-          block.call(" => #{cmd.encoding.name}; __ENCODING__: #{__ENCODING__.name}; LANG: #{ENV['LANG']}; LC_CTYPE: #{ENV['LC_CTYPE']}\n") if verbose
-        end
-        EY.ui.debug(cmd)
-        block.call("Command: #{cmd}\n") if verbose
-        if ENV["NO_SSH"]
-          block.call("NO_SSH is set. No output.")
-          true
-        else
-          begin
-            options_for_ssh = {:paranoid => false}
-            options_for_ssh[:verbose] = ENV["DEBUG"].downcase.to_sym if ENV["DEBUG"]
-            Net::SSH.start(hostname, environment.username, options_for_ssh) do |net_ssh|
-              net_ssh.open_channel do |channel|
-                channel.exec cmd do |_, success|
-                  unless success
-                    block.call "Remote command execution failed"
-                    return false
-                  end
-
-                  channel.on_data do |_, data|
-                    block.call data
-                  end
-
-                  channel.on_extended_data do |_, _, data|
-                    block.call data
-                  end
-
-                  channel.on_request("exit-status") do |_, data|
-                    exit_code = data.read_long
-                  end
-
-                  channel.on_request("exit-signal") do |_, data|
-                    exit_code = 255
-                  end
-                end
-              end
-
-              net_ssh.loop
-            end
-            exit_code.zero?
-          rescue Net::SSH::AuthenticationFailed
-            raise EY::Error, "Authentication Failed: Please add your environment's ssh key with: ssh-add path/to/key"
-          end
-        end
-      end
-
-      def invoke(action, &block)
-        action.call do |cmd|
-          ssh cmd, action.verbose do |chunk|
-            $stdout << chunk
-            block.call(chunk) if block
-          end
-        end
-      end
-
-      def instances_data
-        environment.instances.select { |inst| inst.has_app_code? }.map do |i|
-          {
-            :hostname => i.engineyard_serverside_hostname,
-            :roles    => [i.role],
-            :name     => i.name,
-          }
-        end
-      end
-
-      def app_master?
-        environment.app_master == self
-      end
-    end
-  end
-end