ey_enzyme 0.9.48 → 2.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c71e1af54ddfa6f64786576598b0f828f1528bff
+  data.tar.gz: 8586d600ca185ccc67b491393f4b0bba56bd445e
+SHA512:
+  metadata.gz: c6e747c25787291bb9dffdf1077a645933885ad23bd5f97df67190ee3c22968dc08f11ad025fc7b84ff44fc8196ad0a0de5088e4c780ffb2db9f157ebbeb7f97
+  data.tar.gz: 7ff5be0a8cfc497cabf97c30ff01c0ea497210829dbb71fdaf48414d8ad917ce563610d0e43a2194188937a3e65d91fa877a3a0e14ce13f68ac817bfad801f40

data/lib/ey_enzyme/api/client.rb

@@ -0,0 +1,133 @@
+require 'timeout'
+require 'rest_client'
+
+module EY
+  module Enzyme
+    module API
+      class Client
+
+        REST_TIMEOUT_SECONDS = 60
+        TOTAL_TIMEOUT_SECONDS = 600
+        RETRY_TIMEOUT_SECONDS = 30
+
+        attr_reader :api_url, :instance_id, :token, :logger
+
+        def initialize(api_url, instance_id, token, logger)
+          @api_url     = api_url
+          @instance_id = instance_id
+          @token       = token
+          @logger      = logger
+        end
+
+        def rest
+          @rest ||= RestClient::Resource.new(
+            api_url,
+            :timeout => REST_TIMEOUT_SECONDS
+          )
+        end
+
+        def report(message)
+          safe_api("report", :message => message)
+        end
+
+        def notify_success
+          retry_api("completed", :status => 'true')
+        end
+
+        def notify_error(type, error)
+          log :exception, "Notifying #{type} error", error
+          call_api("error", params_for(type, error))
+        rescue RestClient::Exception
+          log :exception, "Failed to notify of #{type} error", $!
+          raise
+        end
+
+        def dna
+          retry_api("dna")
+        end
+
+        def custom_recipe_url
+          if response = retry_api("custom-recipe")
+            response["url"]
+          end
+        end
+
+        #upload, as in, upload the log file output of the chef run
+        def upload(type, file)
+          retry_api("store_gzip", :type => type, :file => file)
+        rescue => e
+          #blanket rescue feels dangerous, but we're at least logging it
+          #we don't have all the information we'd like to include in the exception message here anyway
+          #caller (CookbookSet#upload) should check return value and notify failure
+          api_error("store_gzip", e)
+          false
+        end
+
+        private
+
+        def log(level, *msg)
+          @logger.send(level, *msg) if @logger
+        end
+
+        def keys
+          @keys ||= {:instance_id => instance_id, :token => token}
+        end
+
+        def params_for(type, error)
+          { :class     => error.class,
+            :message   => error.message,
+            :backtrace => error.backtrace,
+            :where_failed => type }
+        end
+
+        def call_api(path, opts = {})
+          log :debug, "API call path: #{path.inspect}, data: #{opts.inspect}"
+          JSON.parse(
+            rest[path].post(
+              opts.merge(keys),
+              {
+                :content_type => "application/json",
+                :accept => "application/json"
+              }
+            )
+          )
+        end
+
+        def retry_api(path, opts={})
+          Timeout.timeout(TOTAL_TIMEOUT_SECONDS) do
+            loop do
+              if result = safe_api(path, opts)
+                return result
+              end
+              sleep RETRY_TIMEOUT_SECONDS
+            end
+          end
+        rescue Timeout::Error
+          false
+        end
+
+        def safe_api(path, opts = {})
+          begin
+            return call_api(path, opts)
+          rescue RestClient::BadGateway, RestClient::GatewayTimeout
+            api_error(path, $!)
+            return false
+          rescue RestClient::ServiceUnavailable => e
+            response = e.response
+            if response.headers[:content_type] =~ /json/
+              hash = JSON.parse(response)
+              log :error, "Failed to fetch DNA: #{hash.delete('message')}: #{hash.inspect}"
+            end
+
+            api_error(path, e)
+            return false
+          end
+        end
+
+        def api_error(path, error)
+          log :exception, "API request failed", error
+        end
+      end
+    end
+  end
+end

data/lib/ey_enzyme/api.rb

@@ -1,117 +1,44 @@
-# encoding: utf-8
+require 'ey_enzyme/api/client'
 
-module EY::Enzyme
-  class API
-    def initialize(api_url, instance_id, token, log_file = "/var/log/enzyme.log")
-      @api_url     = api_url
-      @instance_id = instance_id
-      @token       = token
-      @logger      = MultiLogger.new(log_file)
-      @rest        = RestClient::Resource.new(api_url, :timeout => api_rest_timeout_seconds)
-    end
-
-    def report(message)
-      safe_api("report", :message => message)
-    end
-
-    def notify_success
-      retry_api("completed", :status => 'true')
-    end
-
-    def notify_error(type, error)
-      @logger.exception "Notifying #{type} error", error
-      call_api("error", params_for(type, error))
-    rescue RestClient::Exception
-      @logger.exception "Failed to notify of #{type} error", $!
-      raise
-    end
-
-    def dna
-      retry_api("dna")
-    end
-
-    def custom_recipe_url
-      if response = retry_api("custom-recipe")
-        response["url"]
+module EY
+  module Enzyme
+    module API
+      class Unconfigured < StandardError
       end
-    end
-
-    #upload, as in, upload the log file output of the chef run
-    def upload(type, content)
-      content = content.force_encoding('UTF-8') if content.respond_to?(:force_encoding)
-      retry_api("store", :type => type, :content => content)
-    rescue => e
-      #blanket rescue feels dangerous, but we're at least logging it
-      #we don't have all the information we'd like to include in the exception message here anyway
-      #caller (CookbookSet#upload) should check return value and notify failure
-      api_error("store", e)
-      false
-    end
-
-    private
-
-    def keys
-      @keys ||= {:instance_id => @instance_id, :token => @token}
-    end
-
-    def params_for(type, error)
-      { :class     => error.class,
-        :message   => error.message,
-        :backtrace => error.backtrace,
-        :where_failed => type }
-    end
 
-    def call_api(path, opts={})
-      @logger.debug "API call path: #{path.inspect}, data: #{opts.inspect}"
-      JSON.parse(@rest[path].post(opts.merge(keys).to_json,
-        {"Content-Type" => "application/json", "Accept" => "application/json"}))
-    end
+      def self.configure(api_url, instance_id, token, logger)
+        @client = Client.new(api_url, instance_id, token, logger)
+        self
+      end
 
-    def api_rest_timeout_seconds
-      60
-    end
+      def self.client
+        raise Unconfigured unless @client
+        @client
+      end
 
-    def api_max_total_seconds
-      10 * 60
-    end
+      def self.report(message)
+        client.report(message)
+      end
 
-    def api_sleep_before_retry_seconds
-      30
-    end
+      def self.notify_success
+        client.notify_success
+      end
 
-    def retry_api(path, opts={})
-      Timeout.timeout(api_max_total_seconds) do
-        loop do
-          if result = safe_api(path, opts)
-            return result
-          end
-          sleep api_sleep_before_retry_seconds
-        end
+      def self.notify_error(type, error)
+        client.notify_error(type, error)
       end
-    rescue Timeout::Error
-      false
-    end
 
-    def safe_api(path, opts={})
-      begin
-        return call_api(path, opts)
-      rescue RestClient::BadGateway, RestClient::GatewayTimeout
-        api_error(path, $!)
-        return false
-      rescue RestClient::ServiceUnavailable => e
-        response = e.response
-        if response.headers[:content_type] =~ /json/
-          hash = JSON.parse(response)
-          @logger.error "Failed to fetch DNA: #{hash.delete('message')}: #{hash.inspect}"
-        end
+      def self.dna
+        client.dna
+      end
 
-        api_error(path, e)
-        return false
+      def self.custom_recipe_url
+        client.custom_recipe_url
       end
-    end
 
-    def api_error(path, error)
-      @logger.exception("API request failed", error)
+      def self.upload(type, file)
+        client.upload(type, file)
+      end
     end
   end
 end

data/lib/ey_enzyme/cli.rb

@@ -5,44 +5,66 @@ module EY::Enzyme
     def self.run(args)
       $stdout.sync = true
 
-      defaults = {:config => '/etc/engineyard/dracul.yml', :keep => 5, :chef_bin => 'chef-solo',
-                  :logfile => "/var/log/enzyme.log"}
+      defaults = {
+        chef_bin:   'chef-client',
+        run_list:   ['recipe[ey-init::main]'],
+        config:     '/etc/engineyard/dracul.yml',
+        base_path:  '/etc/chef/',
+        logfile:    '/var/log/ey-enzyme.log',
+        log_level:  :info,
+        keep:       5,
+        run_custom: true,
+        download:   true,
+        mode:       :deploy
+      }
       options = {}
 
       opts = OptionParser.new do |opts|
         opts.version = EY::Enzyme::VERSION
-        opts.banner = "Usage: ey-enzyme [-flag] [argument]"
+        opts.banner = "Usage: ey-enzyme <options> [argument]"
         opts.define_head "ey-enzyme: running recipes..."
         opts.separator '*'*80
 
-        opts.on("--quick", "Set the recipes to run in quick mode") do
-          options[:quick] = true
-        end
-
-        opts.on("--logfile", "Set the logfile (defaults to /var/log/enzyme.log)") do |path|
+        opts.on("--logfile", "Set the logfile (default: #{defaults[:logfile]})") do |path|
           options[:logfile] = path
         end
 
-        opts.on("--config CONFIG", "Use config file") do |config|
+        opts.on("--config CONFIG", "Use config file (default: #{defaults[:config]})") do |config|
           options[:config] = config
         end
 
-        opts.on("--chef-bin PATH", "Use this chef-solo executable to run recipes") do |binary|
-          options[:chef_bin] = binary
+        opts.on("--cookbooks PATH", "Use the given path for retrieving and using the cookbooks (default: #{defaults[:base_path]}") do |path|
+          options[:base_path] = path
         end
 
-        opts.on("--main", "Run main recipes") do
-          options[:type] = :main
+        opts.on("--chef-bin PATH", "Use this chef-solo executable to run recipes") do |binary|
+          options[:chef_bin] = binary
         end
 
-        opts.on("--custom", "Run custom recipes") do
-          options[:type] = :custom
+        opts.on("--run-list RECIPES", "Comma-separated list of recipes to run") do |recipe_list|
+          options[:run_list] = recipe_list.split(',').collect {|r| "recipe[#{r}]" }
         end
 
         opts.on("--report message", "Report a status") do |message|
-          options[:report] = true
+          options[:mode] = :report
           options[:message] = message
         end
+
+        opts.on("--no-custom", "Do not overlay custom recipes") do
+          options[:run_custom] = false
+        end
+
+        opts.on("--cached", "Used the cached version of the cookbooks and dna.json") do
+          options[:download] = false
+        end
+
+        opts.on("--refresh-dna", "Write new dna even if --cached is on") do
+	  options[:refresh_dna] = true
+        end
+
+        opts.on("--verbose", "Show debug logs as well") do
+          options[:log_level] = :debug
+        end
       end
 
       opts.parse!(args)
@@ -50,43 +72,57 @@ module EY::Enzyme
       config = options[:config] || defaults[:config]
       cli    = new(defaults.merge(YAML.load_file(config)).merge(options))
 
-      if options[:report]
+      if options[:mode] == :report
         cli.report(options[:message])
-      elsif options[:type]
-        cli.deploy
       else
-        abort opts.to_s
+        cli.deploy
       end
 
-
     rescue OptionParser::InvalidOption
       $stderr.puts "#{File.basename($0)} #{$!.message}"
       abort opts.to_s
+
     rescue *IGNORABLE_EXCEPTIONS
       raise
+
     rescue DeployError
       if cli
+        cli.report $!.message
         cli.notify_user_error($!)
         exit 0
       end
       raise
+
+    rescue DNAError
+      if cli
+        cli.report $!.message
+        cli.notify_system_error($!)
+        exit 0
+      end
+      raise
+
     rescue Exception
       if cli
         cli.notify_system_error($!)
         exit 0
       end
       raise
+
     end
 
     def initialize(opts={})
       @opts   = opts
-      @api    = API.new(opts[:api], opts[:instance_id], opts[:token], opts[:logfile])
-      @logger = MultiLogger.new(opts[:logfile])
+      @logger = opts[:logger] = MultiLogger.new(opts[:logfile])
+      @api = API
+      @api.configure(opts[:api], opts[:instance_id], opts[:token], opts[:logger])
+
+      @logger.level = opts[:log_level]
 
       @opts[:timestamp] = Time.now.strftime("%Y-%m-%dT%H-%M-%S")
     end
 
     def report(message)
+      @logger.debug "REPORT MESSAGE: #{message}"
       @api.report(message)
     end
 
@@ -98,74 +134,95 @@ module EY::Enzyme
       @api.notify_error("user", error)
     end
 
-    MAIN_RECIPE_PATH = '/etc/chef/recipes'
-    CUSTOM_RECIPE_PATH = '/etc/chef-custom/recipes'
-
     def deploy
       @logger.info "Starting configuration run"
 
-      json = update_dna
-
-      case @opts[:type]
-      when :main
-        run_main
-        run_custom(json)
-      when :custom
-        run_custom(json)
-      else
-        raise "Unknown type: #{@opts[:type].inspect}"
-      end
+      ensure_resolv_conf_is_functional
+      update_dna
 
+      run_cookbooks
       @api.notify_success
     end
 
-    def run_main
-      report 'running main recipes'
-      main_cookbooks.run
+    def cookbook_set
+      CookbookSet.new(@api, @opts)
     end
 
-    def run_custom(json)
-      report 'running custom recipes if they exist'
-      url = @opts.has_key?(:custom_recipes_url) ? @opts[:custom_recipes_url] : @api.custom_recipe_url
-      update_custom_dna(json) if url
+  private
+
+    def run_cookbooks
+      report "Initializing cookbook run"
+      cookbook_set.run
+    end
 
-      @custom_cookbooks ||= CookbookSet.new(@opts, "custom", CUSTOM_RECIPE_PATH, url, @api)
+    ## Resovlve resolv.conf stuff
 
-      @custom_cookbooks.run
+    def ensure_resolv_conf_is_functional
+      @logger.info "Checking resolv.conf"
+      unless does_hostname_resolve?
+        modify_resolv_conf
+      end
     end
 
-    def main_cookbooks
-      @main_cookbooks ||= CookbookSet.new(@opts, "main", MAIN_RECIPE_PATH, @opts[:recipes_url], @api)
+    def resolv_conf
+      File.read('/etc/resolv.conf')
     end
 
-    def update_dna
-      @logger.debug "Getting instance's DNA"
+    def does_hostname_resolve?
+      hostname = `/bin/hostname --fqdn 2>/dev/null`
+      ! hostname.empty?
+    end
 
-      unless json = @api.dna
-        raise DNAError, "failed to fetch DNA"
+    def add_to_search(path, term)
+      data = File.read(path)
+      new_data = data.gsub(/^\s*(search\s+.*)$/) do |match|
+        if match =~ /\b#{term}\b/
+          match
+        else
+          # only actually append the term to the search line if it's not already there.
+          @logger.info "Adding #{term} to the #{path} 'search' line"
+          "#{match} #{term}"
+        end
       end
-
-      @logger.debug "Writing json dna to file system"
-      update_main_dna(json)
-      json
+      File.open(path,'w') {|fh| fh.write new_data}
     end
 
-    def update_main_dna(json)
-      main_json = json.dup
-      main_json['run_list'] = 'recipe[ey-base]'
-      main_json["quick"] = true if @opts[:quick]
-      update_chef_dna("/etc/chef/dna.json", main_json)
+    def modify_resolv_conf
+      original_resolv_conf = resolv_conf
+
+      add_to_search('/etc/resolv.conf','compute-1.internal')
+
+      if does_hostname_resolve?
+        # if it works, make it survive a dhcp lease renewal
+        add_to_search('/etc/resolv.conf.head', 'compute-1.internal')
+      else
+        @logger.info "Change failed; still can't resolve hostname. Reverting change."
+        File.open('/etc/resolv.conf','w') {|fh| fh.write original_resolv_conf}
+      end
     end
 
-    def update_custom_dna(json)
-      custom_json = json.dup
-      custom_json['run_list'] = 'recipe[main]'
-      # Make sure the path exist, it's soooo wrong to write this file before the cookbooks have been downloaded nor the config written
-      FileUtils.mkdir_p('/etc/chef-custom/') unless File.exists?('/etc/chef-custom/')
-      update_chef_dna("/etc/chef-custom/dna.json", custom_json)
+    ### DNA.json manipulation
+
+    def update_dna
+      FileUtils.mkdir_p @opts[:base_path]
+      file = File.join(@opts[:base_path],'dna.json')
+
+      if File.exists?(file) and not @opts[:refresh_dna] and not @opts[:download]
+        @logger.info "Skipping download of fresh DNA - using existing #{@chef_dna} file."
+        return
+      end
+
+      report "Fetching instance DNA"
+      raise DNAError, "Failed to fetch DNA" unless json = @api.dna
+
+      main_json = {}
+      main_json['run_list'] = @opts[:run_list]
+      main_json['dna'] = json.dup
+      save_dna(file,main_json)
     end
 
-    def update_chef_dna(file, json)
+    def save_dna(file, json)
+      @logger.debug "Writing json dna to #{file}"
       File.open(file, 'w') do |f|
         f.puts JSON.pretty_generate(json)
         f.chmod(0600)

data/lib/ey_enzyme/cookbook_set.rb

@@ -1,99 +1,175 @@
 module EY::Enzyme
   class CookbookSet
-    def initialize(opts, name, recipes_path, recipes_url, api)
-      @opts           = opts
-      @name           = name
-      @recipes_path   = recipes_path
-      @logger         = MultiLogger.new(opts[:logfile])
-      @timestamp      = Time.now.strftime("%Y-%m-%dT%H-%M-%S")
-      @chef_log       = "/var/log/chef.#{name}.#{@timestamp}.log"
-      @recipes_url    = recipes_url
-      @api            = api
+
+    def initialize(api, opts)
+      @opts             = opts
+      @api              = api
+      @chef_config      = File.join(opts[:base_path], "solo.rb")
+      @chef_dna         = File.join(opts[:base_path], "dna.json")
+      @recipes_path     = File.join(opts[:base_path], "recipes")
+      @main_recipes_url = opts[:recipes_url]
+      @user_recipes_url = opts.has_key?(:custom_recipes_url) ? opts[:custom_recipes_url] : api.custom_recipe_url
+      @logger           = opts[:logger]
+      @timestamp        = Time.now.strftime("%Y-%m-%dT%H-%M-%S")
+      @chef_log         = "/var/log/chef.#{@timestamp}.log"
     end
 
     def run
-      unless @recipes_url
-        @logger.info "No recipes for #{@name} chef run. Skipping"
-        return
+      if @main_recipes_url
+        setup
+        execute
+      else
+        @logger.info "No recipes for chef run. Skipping"
       end
-
-      setup
-      execute
     ensure
       upload
     end
 
+  private
+
     def setup
-      @logger.info "Starting #{@name} chef run"
+      @logger.info "Starting chef run"
 
       abort("Instance ID mismatch") unless instance_id_valid?
       FileUtils.rm(@chef_log) if File.exist?(@chef_log)
 
-      FileUtils.mkdir_p('/etc/chef-custom/') unless File.exists?('/etc/chef-custom/')
+      # Create the EC2 hint for ohai
+      # See: https://geekblood.wordpress.com/2015/03/13/enabling-ec2-metadata-in-ohai/
+      FileUtils.mkdir_p("#{@opts[:base_path]}/ohai/hints/")
+      FileUtils.touch("#{@opts[:base_path]}/ohai/hints/ec2.json")
 
-      File.open(chef_config, "w") do |f|
+      File.open(@chef_config, "w") do |f|
         f.puts <<-EOS
           cookbook_path     "#{@recipes_path}/cookbooks"
           file_store_path   "#{@recipes_path}/"
           file_cache_path   "#{@recipes_path}/"
+          data_bag_path     "#{@recipes_path}/data_bags"
           log_location      "#{@chef_log}"
           log_level         :info
           node_name         "#{@opts[:instance_id]}"
         EOS
       end
 
-      @logger.info "Removing #{@name} cookbooks"
+      if @opts[:download]
+        @logger.info "Removing cookbooks"
+        FileUtils.rm_rf(@recipes_path)
+        FileUtils.mkdir_p(@recipes_path)
+
+        @logger.info "Downloading main cookbooks"
+        download_cookbooks
 
-      FileUtils.rm_rf(@recipes_path)
+        unless @user_recipes_url.nil?
+          if @opts[:run_custom]
+            @logger.info "Overlaying custom user cookbook recipes"
+            overlay_custom_cookbooks
+          else
+            @logger.info "Skipping overlay of custom cookbook recipes"
+          end
+        end
+      else
+        @logger.info "Skipping download of new cookbooks - using existing cookbooks in #{@recipes_path}"
+      end
+    end
+
+    def download_cookbooks
       FileUtils.mkdir_p(@recipes_path)
+      result = %x[cd #{@recipes_path} && curl -fs '#{@main_recipes_url}' | tar -zxv]
+      if $?.exitstatus > 0
+        @logger.error "Failed to download and untar main cookbook."
+        @logger.error "Error output: #{result}"
+        raise DeployError, "Main cookbook download failed."
+      end
+    end
+
+    def overlay_custom_cookbooks
+      Dir.mktmpdir do |tmpdir| 
+        file=File.join(tmpdir,'user_recipes.tgz')
+        result = %x[curl -fs '#{@user_recipes_url}' -o #{file}]
+        if $?.exitstatus > 0
+          @logger.error "Failed to download user cookbook from #{@user_recipes_url}"
+          raise DeployError, "User cookbook download failed."
+        end
+
+        #Check COMPATIBILITY.txt file for release compatibilities
+        compat = %x[tar -azxf '#{file}' COMPATIBILITY.txt 2>/dev/null]
+        if $?.exitstatus == 0
+          # TODO: Determine how to compare against opts[:release_label]
+          # if not compatibible, log it, and raise DeployError, "Incompatible user cookbook found."
+        else
+          @api.report "WARNING: No COMPATIBILITY.txt file found in user cookbook."
+        end
+
+        result = %x[cd #{@recipes_path} && tar -zxvf #{file}]
+        if $?.exitstatus > 0
+          @logger.error "Failed to overlay user cookbook over main cookbook."
+          @logger.error "Error output: #{result}"
+          raise DeployError, "User cookbook overlay failed."
+        end
+
+      end
     end
 
     def execute
-      command = "#{@opts[:chef_bin]} -j #{chef_dna} -c #{chef_config} -r \"#{@recipes_url}\" > #{@chef_log} 2>&1"
+      # Remove any stacktrace file from previous runs
+      stacktrace_file = File.join(@recipes_path,"chef-stacktrace.out")
+      FileUtils.rm_f stacktrace_file
+      tail = nil
+      if @logger.debug?
+        system("touch #{@chef_log}")
+        tail = Thread.new do
+          File.open(@chef_log, "r") do |fp|
+            while true do
+              select([fp])
+              $stderr << fp.read
+            end
+          end
+        end
+      end
+      command = "#{@opts[:chef_bin]} -j #{@chef_dna} -c #{@chef_config} > #{@chef_log} 2>&1"
       @logger.debug "Running: #{command}"
       if system(command)
         @logger.info "Running telinit"
         system("telinit q")
-        @logger.info "Finished #{@name} chef run"
+        @logger.info "Finished chef run"
       else
-        @logger.error("#{@name} chef run failed. Reporting error")
-        @logger.error("#{@name} error output: #{chef_error_from_log}")
-        raise DeployError, "#{@name} chef run failed"
+        @logger.error("Chef run failed. Reporting error")
+        @logger.error("Error output: #{chef_error_from_log}")
+        raise DeployError, "Chef run failed - see log file"
       end
     ensure
       if File.exists?(@chef_log)
-        FileUtils.ln_sf(@chef_log, "/var/log/chef.#{@name}.log")
+        if File.exists?(stacktrace_file)
+          st_contents = File.read(stacktrace_file)
+          File.open(@chef_log, "a") do |l|
+            l.puts "\n-----------"
+            l.puts "Stack Trace (from #{stacktrace_file})"
+            l.puts "-----------\n\n#{st_contents}"
+          end
+        end
+        FileUtils.ln_sf(@chef_log, "/var/log/chef.log")
       end
+      tail && tail.kill
     end
 
     def upload
       return unless File.exist?(@chef_log)
 
       file = "#{@chef_log}.#{rand(1000)}.gz"
-      Zlib::GzipWriter.open(file) { |io| io << File.read(@chef_log) }
+      Zlib::GzipWriter.open(file) do |io|
+        io << File.read(@chef_log)
+      end
 
-      unless @api.upload(@name, File.read(file))
-        @logger.error "Failed to upload #{@name} log. Reporting error"
-        raise UploadError, "failed to upload #{@name} log"
+      unless @api.upload('main', File.new(file))
+        @logger.error "Failed to upload chef log. Reporting error"
+        raise UploadError, "Failed to upload chef log"
       end
     rescue UploadError => error
+      @api.report error.message
       @api.notify_error("logupload", error)
     ensure
       FileUtils.rm_f(file) if file
     end
 
-    def main?
-      @name == "main"
-    end
-
-    def chef_config
-      main? ? "/etc/chef/solo.rb" : "/etc/chef-custom/solo.rb"
-    end
-
-    def chef_dna
-      main? ? '/etc/chef/dna.json' : '/etc/chef-custom/dna.json'
-    end
-
     def chef_error_from_log
       unless File.exist?(@chef_log)
         return "(log doesn't exist)"
@@ -122,7 +198,9 @@ module EY::Enzyme
     end
 
     def local_instance_id
-      @local_instance_id ||= open('http://169.254.169.254/latest/meta-data/instance-id').read
+      @local_instance_id ||= URI.open("http://169.254.169.254/latest/meta-data/instance-id",
+ &:read)
     end
+
   end
 end

data/lib/ey_enzyme/multi_logger.rb

@@ -1,11 +1,30 @@
 module EY::Enzyme
   class MultiLogger
 
+    SEVERITIES = {
+      :fatal => Logger::FATAL,
+      :error => Logger::ERROR,
+      :warn  => Logger::WARN,
+      :info  => Logger::INFO,
+      :debug => Logger::DEBUG,
+    }
+
     def initialize(log_file)
       @enzyme_log = Logger.new(log_file)
       @stderr_log = Logger.new($stderr)
     end
 
+    def level=(level)
+      @level = level
+      raise "Invalid log level: #{level}" unless SEVERITIES[level]
+      @enzyme_log.level = SEVERITIES[:debug]
+      @stderr_log.level = SEVERITIES[level]
+    end
+
+    def debug?
+      @level == :debug
+    end
+
     def debug(message)
       log(:debug, message)
     end

data/lib/ey_enzyme/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Enzyme
-    VERSION = "0.9.48"
+    VERSION = "2.0.7"
   end
 end

data/lib/ey_enzyme.rb

@@ -3,16 +3,16 @@ require "open-uri"
 require "zlib"
 require "logger"
 require "optparse"
+require "fileutils"
 
 require 'json'
 require 'restclient'
 
 module EY; end
+require "ey_enzyme/api"
 
 require "ey_enzyme/multi_logger"
-require "ey_enzyme/api"
 require "ey_enzyme/cli"
-require "ey_enzyme/old_cli"
 require "ey_enzyme/cookbook_set"
 require "ey_enzyme/version"
 

metadata

@@ -1,160 +1,161 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ey_enzyme
-version: !ruby/object:Gem::Version 
-  hash: 91
-  prerelease: 
-  segments: 
-  - 0
-  - 9
-  - 48
-  version: 0.9.48
+version: !ruby/object:Gem::Version
+  version: 2.0.7
 platform: ruby
-authors: 
+authors:
 - Engine Yard Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-02-25 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2021-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.1
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.1
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rest-client
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 6
-        - 1
-        version: 1.6.1
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.1
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 1
-        - 2
-        version: "1.2"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: fakeweb
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: fakeweb-matcher
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id006
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Gem for kicking off chef recipes
 email: ninja@engineyard.com
-executables: 
+executables:
 - ey-enzyme
-- ey-recipes
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- bin/ey-enzyme
+- lib/ey_enzyme.rb
 - lib/ey_enzyme/api.rb
+- lib/ey_enzyme/api/client.rb
 - lib/ey_enzyme/cli.rb
 - lib/ey_enzyme/cookbook_set.rb
 - lib/ey_enzyme/multi_logger.rb
-- lib/ey_enzyme/old_cli.rb
 - lib/ey_enzyme/version.rb
-- lib/ey_enzyme.rb
-- bin/ey-enzyme
-- bin/ey-recipes
-homepage: http://github.com/engineyard/ey_enzyme
+homepage: https://github.com/engineyard/ey_enzyme
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 2.6.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gem for kicking off chef recipes
 test_files: []
-

data/bin/ey-recipes

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'ey_enzyme'
-
-EY::Enzyme::OldCLI.run(ARGV)

data/lib/ey_enzyme/old_cli.rb

@@ -1,35 +0,0 @@
-module EY::Enzyme
-  class OldCLI
-    def self.run(args)
-      new_args = []
-
-      opts = OptionParser.new do |opts|
-        opts.version = "0.0.1"
-
-        opts.banner = "Usage: ey-recipes[-flag] [argument]"
-        opts.define_head "ey-recipes: running recipes..."
-        opts.separator '*'*80
-
-        opts.on("-c CONFIG", "--config CONFIG", "Use config file") do |config|
-          # NO-OP
-        end
-
-        opts.on("--deploy-main ENV", "Run main recipes") do |env_name|
-          new_args << "--main"
-        end
-
-        opts.on("-d ENV", "--deploy ENV", "Run custom recipes") do |env_name|
-          new_args << "--custom"
-        end
-      end
-
-      opts.parse!(args)
-
-      if new_args.any?
-        CLI.run(new_args)
-      else
-        $stderr.puts opts
-      end
-    end
-  end
-end