ey-flex-test 0.3.3

data/lib/ey-api.rb

@@ -0,0 +1,22 @@
+module EyApi
+  def call_api(path, opts={})
+    JSON.parse(@rest["/api/#{path}"].post(@keys.merge(opts), {"Accept" => "application/json"}))
+  rescue RestClient::RequestFailed => e
+    case e.http_code
+    when 503
+      sleep 10 # Nanite, save us...
+      retry
+    else
+      raise "API call to Engine Yard failed. Are there any running instances for #{@env}?"
+    end
+  end
+  
+  def get_envs
+    @_envs ||= call_api("environments")
+  end
+  
+  def get_json(instance_id = nil)
+    env = get_envs[@env]
+    call_api("json_for_instance", :id => env['id'], :instance_id => instance_id)
+  end
+end

data/lib/ey.rb

@@ -0,0 +1,305 @@
+require 'rubygems'
+require 'aws/s3'
+require 'date'
+require 'digest'
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'bucket_minder')
+require 'rest_client'
+require 'json'
+require 'open-uri'
+require 'zlib'
+require 'stringio'
+require 'ey-api'
+
+$stdout.sync = true
+
+module EY
+
+  class ChefRecipes
+    
+    include EyApi
+    
+    def initialize(opts={})
+      raise ArgumentError.new("must provide environment name") unless opts[:env] or opts[:command] == :get_envs
+      @opts = opts
+      @eyenv = opts[:eyenv] || 'production'
+      @env = opts[:env]
+      @recipeloc = opts[:recipeloc] || "/etc/chef-custom/recipes"
+      @rest = RestClient::Resource.new(opts[:api])
+      @keys = {:aws_secret_id => @opts[:aws_secret_id], :aws_secret_key => @opts[:aws_secret_key]}
+      if @opts[:identifier]
+        @opts[:instance_id] = @opts[:identifier]
+      end
+      @lock = Mutex.new
+      @bucket = BucketMinder.new(@opts)
+      unless get_envs[@env] or opts[:command] == :get_envs
+        puts %Q{#{@env} is not a valid environment name, your available environments are:\n#{get_envs.keys.join("\n")}}
+        exit 1
+      end  
+    end
+    
+    def converge
+      return if @bucket.empty? and !@opts[:main]
+      require 'chef'
+      require 'chef/client'
+      FileUtils.mkdir_p @recipeloc
+      logtype = nil
+      build_problem = false
+      with_logging do
+        begin
+          instance_id = open("http://169.254.169.254/latest/meta-data/instance-id").gets
+          defaults = {
+            :log_level => :info,
+            :solo => true,
+            :cookbook_path => "#{@recipeloc}/cookbooks",
+            :file_store_path => "#{@recipeloc}/",
+            :file_cache_path => "#{@recipeloc}/",
+            :node_name => instance_id
+          }
+          Chef::Config.configure { |c| c.merge!(defaults) }
+          Chef::Log::Formatter.show_time = false
+          Chef::Log.level(Chef::Config[:log_level])
+          Chef::Log.info "[Begin] Chef converge of Amazon instance: #{instance_id}"
+
+          Chef::Log.info "Removing cookbooks"
+          if File.exist?("#{@recipeloc}/cookbooks")
+            FileUtils.rm_rf("#{@recipeloc}/cookbooks")
+          end
+          
+          if @opts[:main]
+            logtype = "main.logs"
+            Chef::Log.info "Installing main recipes"
+            install_main_recipes
+          else
+            logtype = "logs"
+            Chef::Log.info "Installing custom recipes"
+            install_recipes
+          end
+          Chef::Log.info "Getting instance's json dna"
+          json = get_json(instance_id)
+          json["quick"] = true if @opts[:quick]
+          json["removed_applications"] = self.class.find_removed_applications(json)
+          Chef::Log.info "Writing json dna to file system"
+          File.open("/etc/chef/dna.json", 'w'){|f| f.puts JSON.pretty_generate(json)}
+          Chef::Log.info "Running Chef solo"
+          c = Chef::Client.new
+          c.json_attribs = json
+          c.run_solo
+          Chef::Log.info "Running telinit"
+          `telinit q`
+          Chef::Log.info "[End] Chef converge of Amazon instance: #{instance_id}"          
+        rescue Object => e
+          build_problem = true
+          Chef::Log.error(describe_error(e))
+        end  
+      end
+      
+      begin
+        @bucket = BucketMinder.new(@opts.merge(:type => logtype, :extension => 'gz', :instance_id => nil))
+        upload_logs(file)
+        @bucket.cleanup
+        exit(1) if build_problem
+      rescue AWS::S3::InternalError
+        sleep 2
+        retry
+      end
+    end
+    
+    def install_main_recipes
+      unless @opts[:main_recipes]
+        puts "you must specify :main_recipes: in your ey-cloud.yml"
+        exit 1
+      end  
+      recipes_path = Chef::Config[:cookbook_path].gsub(/cookbooks/, '')
+      FileUtils.mkdir_p recipes_path
+      path = File.join(recipes_path, 'recipes.tgz')
+      File.open(path, 'wb') do |f|
+        f.write open(@opts[:main_recipes]).read
+      end
+      system("cd #{recipes_path} && tar xzf #{path}")
+      FileUtils.rm path
+    end
+    
+    def deploy
+      unless File.exist?("cookbooks")
+        puts "you must run this command from the root of your chef recipe git repo"
+        exit 1
+      end
+      env = get_envs[@env]
+      unless env['instances'] > 0
+        puts "There are no running instances for ENV: #{@env}"
+        exit 1
+      end
+      if upload_recipes
+        if env
+          puts "deploying recipes..."
+          if call_api("deploy_recipes", :id => env['id'] )[0] == 'working'
+            threads = []
+            env['instance_ids'].each do |instance_id|
+              threads << Thread.new { wait_for_logs('logs', instance_id) }
+            end
+            threads.each {|t| t.join}
+          else
+            puts "deploying main recipes failed..."
+          end
+        else
+          puts "No matching environments"
+        end  
+      else
+        puts "Failed to deploy: #{@env}"
+      end  
+    end
+    
+    def rollback
+      @bucket.rollback
+      env = get_envs[@env]
+      if env
+        puts "rolling back recipes..."
+        call_api("deploy_recipes", :id => env['id'] )
+        wait_for_logs('logs')
+      else
+        puts "No matching environments for #{@env}"
+      end
+    end
+    
+    def wait_for_logs(logtype,instance_id=nil)
+      logbucket = BucketMinder.new(@opts.merge(:type => logtype, :extension => 'gz', :instance_id => instance_id))
+      newest = @lock.synchronize { logbucket.list.last }
+      count = 0
+      until @lock.synchronize { newest != logbucket.list.last }
+        print "."
+        sleep 3
+        count += 1
+        if count > 600
+          puts "timed out waiting for deployed logs"
+          exit 1
+        end  
+      end
+      puts
+      puts "retrieving logs..."
+      puts @lock.synchronize { display_logs(logbucket.list.last) }
+    end
+    
+    def deploy_main
+      env = get_envs[@env]
+      if env
+        unless env['instances'] > 0
+          puts "There are no running instances for ENV: #{@env}"
+          exit 1
+        end
+        puts "deploying main EY recipes..."
+        if call_api("deploy_main_recipes", :id => env['id'] )[0] == 'working'
+          threads = []
+          env['instance_ids'].each do |instance_id|
+            threads << Thread.new { wait_for_logs('main.logs', instance_id) }
+          end
+          threads.each {|t| t.join}
+        else
+          puts "deploying main recipes failed..."
+        end  
+      else
+        puts "No matching environments"
+      end  
+    end
+    
+    def display_logs(obj)
+      if obj
+        Zlib::GzipReader.new(StringIO.new(obj.value, 'rb')).read
+      else
+        "no logs..."
+      end
+    end
+    
+    def view_logs
+      env = get_envs[@env]
+      env['instance_ids'].each do |instance_id|
+        logtype = "#{@opts[:main] ? 'main.' : ''}logs"
+        logbucket = BucketMinder.new(@opts.merge(:type => logtype, :extension => 'gz', :instance_id => instance_id))
+        puts "Logs for: #{instance_id}"
+        puts display_logs(logbucket.list.last)
+      end
+    end
+    
+    def upload_recipes
+      file = "recipes.#{rand(1000)}.tmp.tgz"
+      tarcmd = "git archive --format=tar HEAD | gzip > #{file}"
+      if system(tarcmd)
+        @bucket.upload_object(file)
+        @bucket.cleanup
+        true
+      else
+        puts "Unable to tar up recipes for #{@opts[:env]} wtf?"
+        false
+      end
+    end
+    
+    def upload_logs(file)
+      name = "#{file}.#{rand(1000)}.tgz"
+      tarcmd = "cat #{file} | gzip > #{name}"
+      if system(tarcmd)
+        @bucket.upload_object(name)
+        @bucket.cleanup
+        true
+      else
+        puts "Unable to tar up log files for #{@opts[:env]} wtf?"
+        false
+      end    
+    end
+    
+    def cleanup
+      @bucket.cleanup
+    end
+    
+    def list(*args)
+      @bucket.list(*args)
+    end
+    
+    def download(*args)
+      @bucket.download(*args)
+    end
+    
+    def install_recipes
+      file = get_current
+      Dir.chdir(@recipeloc) {
+        system("tar xzf #{file}")
+      }
+      FileUtils.rm file
+    end
+    
+    def get_current
+      @bucket.get_current
+    end
+    
+    def clear_bucket
+      @bucket.clear_bucket
+    end
+    
+    def describe_error(e)
+      "#{e.class.name}: #{e.message}\n #{e.backtrace.join("\n  ")}"
+    end
+    
+    def with_logging(&block)
+      File.open("/var/log/chef.log", 'w') do |file|
+        Chef::Log.init(file)
+        block.call
+      end
+    end
+    
+    def self.find_removed_applications(new_dna, file="/etc/chef/dna.json")
+      json = if file.respond_to?(:string) 
+        file.string 
+      elsif File.exists?(file)
+        IO.read(file)
+      else
+        raise "File Not Found"
+      end
+      
+      old_dna = JSON.parse(json)
+      old_dna['applications'].keys - new_dna['applications'].keys
+    rescue 
+      []
+    end
+    
+  end
+  
+end

data/lib/mysql_backup.rb

@@ -0,0 +1,127 @@
+require 'aws/s3'
+require 'date'
+require 'digest'
+require 'net/http'
+require 'fileutils'
+
+module AWS::S3
+  class S3Object
+    def <=>(other)
+      DateTime.parse(self.about['last-modified']) <=> DateTime.parse(other.about['last-modified'])
+    end
+  end
+end    
+
+module EyBackup
+
+  class MysqlBackup
+    def initialize(opts={})
+      AWS::S3::Base.establish_connection!(
+          :access_key_id     => opts[:aws_secret_id],
+          :secret_access_key => opts[:aws_secret_key]
+        )
+      @dbuser = opts[:dbuser]
+      @dbpass = opts[:dbpass]
+      @databases = opts[:databases]
+      @keep = opts[:keep]
+      @bucket = "ey-backup-#{Digest::SHA1.hexdigest(opts[:aws_secret_id])[0..11]}"
+      @tmpname = "#{Time.now.strftime("%Y-%m-%dT%H:%M:%S").gsub(/:/, '-')}.sql.gz"
+      @env = opts[:env]
+      FileUtils.mkdir_p '/mnt/backups'
+      FileUtils.mkdir_p '/mnt/tmp'
+      begin
+        AWS::S3::Bucket.create @bucket
+      rescue AWS::S3::BucketAlreadyExists
+      end
+      
+      system("mkdir -p #{self.backup_dir}")
+    end
+    
+    def new_backup
+      @databases.each do |db|
+        backup_database(db)
+      end  
+    end
+    
+    def backup_database(database)
+      full_path_to_backup = "#{self.backup_dir}/#{database}.#{@tmpname}"
+      mysqlcmd = "mysqldump -u #{@dbuser} -p'#{@dbpass}' #{database} | gzip - > #{full_path_to_backup}"
+      if system(mysqlcmd)
+        AWS::S3::S3Object.store(
+           "/#{@env}.#{database}/#{database}.#{@tmpname}",
+           open(full_path_to_backup),
+           @bucket,
+           :access => :private
+        )
+        FileUtils.rm full_path_to_backup
+        puts "successful backup: #{database}.#{@tmpname}"
+      else
+        raise "Unable to dump database: #{database}"
+      end
+    end
+    
+    def download(index)
+      idx, db = index.split(":")
+      obj =  list(db)[idx.to_i]
+      puts "downloading: #{normalize_name(obj)}"
+      File.open(normalize_name(obj), 'wb') do |f|
+        print "."
+        obj.value {|chunk| f.write chunk }
+      end
+      puts
+      puts "finished"
+      normalize_name(obj)
+    end
+    
+    def restore(index)
+      name = download(index)
+      db = name.split('.').first
+      cmd = "gunzip -c #{name} | mysql -u #{@dbuser} -p'#{@dbpass}' #{db}"
+      if system(cmd)
+        puts "successfully restored backup: #{name}"
+      else
+        puts "FAIL"
+      end    
+    end
+    
+    def cleanup
+      list('all',false)[0...-(@keep*@databases.size)].each{|o| 
+        puts "deleting: #{o.key}"  
+        o.delete
+      }
+    end
+    
+    def normalize_name(obj)
+      obj.key.gsub(/^.*?\//, '')
+    end
+    
+    def find_obj(name)
+      AWS::S3::S3Object.find name, @bucket
+    end
+    
+    def list(database='all', printer = false)
+      puts "listing #{database} database" if printer
+      backups = []
+      if database == 'all'
+        @databases.each do |db|
+          backups << AWS::S3::Bucket.objects(@bucket, :prefix => "#{@env}.#{db}")
+        end
+        backups = backups.flatten.sort
+      else  
+        backups = AWS::S3::Bucket.objects(@bucket, :prefix => "#{@env}.#{database}").sort
+      end
+      if printer
+        backups.each_with_index do |b,i|
+          puts "#{i}:#{database} #{normalize_name(b)}"
+        end
+      end    
+      backups
+    end
+    
+    protected
+    def backup_dir
+      "/mnt/tmp"
+    end
+    
+  end
+end