stove 1.1.2 → 2.0.0.beta.1

data/lib/stove/cookbook/metadata.rb

@@ -134,7 +134,7 @@ module Stove
           self.instance_eval(IO.read(path), path, 1)
           self
         else
-          raise Stove::MetadataNotFound.new(path)
+          raise Error::MetadataNotFound.new(path: path)
         end
       end
 
@@ -144,9 +144,13 @@ module Stove
         end
       end
 
-      def version(arg = nil)
-        @version = Solve::Version.new(arg) if arg
-        @version.to_s
+      def version(arg = UNSET_VALUE)
+        if arg == UNSET_VALUE
+          @version.to_s
+        else
+          @version = Solve::Version.new(arg)
+          @version.to_s
+        end
       end
 
       def to_hash
@@ -176,15 +180,16 @@ module Stove
       end
 
       private
-        def set_or_return(symbol, arg)
-          iv_symbol = "@#{symbol.to_s}".to_sym
 
-          if arg.nil? && self.instance_variable_defined?(iv_symbol)
-            self.instance_variable_get(iv_symbol)
-          else
-            self.instance_variable_set(iv_symbol, arg)
-          end
+      def set_or_return(symbol, arg)
+        iv_symbol = "@#{symbol.to_s}".to_sym
+
+        if arg.nil? && self.instance_variable_defined?(iv_symbol)
+          self.instance_variable_get(iv_symbol)
+        else
+          self.instance_variable_set(iv_symbol, arg)
         end
+      end
     end
   end
 end

data/lib/stove/error.rb

@@ -1,118 +1,24 @@
 module Stove
-  class Error < StandardError
-    class << self
-      def set_exit_code(code)
-        define_method(:exit_code) { code }
-        define_singleton_method(:exit_code) { code }
-      end
-    end
-
-    set_exit_code 100
-  end
-
-  class InvalidVersionError < Error
-    set_exit_code 101
-
-    def message
-      'You must specify a valid version!'
-    end
-  end
-
-  class MetadataNotFound < Error
-    set_exit_code 102
+  module Error
+    class StoveError < StandardError
+      def initialize(options = {})
+        return super(options[:_message]) if options[:_message]
 
-    def initialize(filepath)
-      @filepath = File.expand_path(filepath) rescue filepath
-    end
+        class_name = self.class.to_s.split('::').last
+        error_key  = Util.underscore(class_name)
 
-    def message
-      "No metadata.rb found at: '#{@filepath}'"
-    end
-  end
-
-  class CookbookCategoryNotFound < Error
-    set_exit_code 110
-
-    def message
-      'The cookbook\'s category could not be inferred from the community site. ' <<
-      'If this is a new cookbook, you must specify the category with the ' <<
-      '--category flag.'
-    end
-  end
-
-  class UserCanceledError < Error
-    set_exit_code 120
-
-    def message
-      'Action canceled by user!'
-    end
-  end
-
-  class GitError < Error
-    set_exit_code 130
-
-    def message
-      'Git Error: ' + super
-    end
-
-    class NotARepo < GitError
-      set_exit_code 131
-
-      def message
-        'Not a git repo!'
+        super I18n.t("stove.errors.#{error_key}", options)
       end
     end
 
-    class DirtyRepo < GitError
-      set_exit_code 132
-
-      def message
-        'You have untracked files!'
+    class ValidationFailed < StoveError
+      def initialize(klass, id, options = {})
+        super _message: I18n.t("stove.validations.#{klass}.#{id}", options)
       end
     end
 
-    class OutOfSync < GitError
-      set_exit_code 133
-
-      def message
-        'Your remote repository is out of sync!'
-      end
-    end
-  end
-
-  class UploadError < Error
-    set_exit_code 140
-
-    def initialize(response)
-      @response = response
-    end
-
-    def message
-      "The following errors occured when uploading:\n" <<
-        (@response.parsed_response['error_messages'] || []).map do |error|
-          "  - #{error}"
-        end.join("\n")
-    end
-  end
-
-  class BadResponse < Error
-    set_exit_code 150
-
-    def initialize(response)
-      @response = response
-    end
-
-    def message
-      "The following errors occured when making the request:\n" <<
-        @response.parsed_response
-    end
-  end
-
-  class AbstractFunction < Error
-    set_exit_code 160
-  end
-
-  class InvalidChangelogFormat < Error
-    set_exit_code 170
+    class GitFailed < StoveError; end
+    class MetadataNotFound < StoveError; end
+    class ServerUnavailable < StoveError; end
   end
 end

data/lib/stove/filter.rb

@@ -0,0 +1,59 @@
+module Stove
+  class Filter
+    include Mixin::Insideable
+    include Mixin::Loggable
+
+    #
+    # The class that created this filter.
+    #
+    # @return [~Plugin::Base]
+    #
+    attr_reader :klass
+
+    #
+    # The message given by the filter.
+    #
+    # @return [String]
+    #
+    attr_reader :message
+
+    #
+    # The block captured by the filter.
+    #
+    # @return [Proc]
+    #
+    attr_reader :block
+
+    #
+    # Create a new filter object.
+    #
+    # @param [~Plugin::Base] klass
+    #   the class that created this filter
+    # @param [String] message
+    #   the message given by the filter
+    # @param [Proc] block
+    #   the block captured by this filter
+    #
+    def initialize(klass, message, &block)
+      @klass   = klass
+      @message = message
+      @block   = block
+    end
+
+    #
+    # Execute this filter in the context of the creating class, inside the
+    # given cookbook's path.
+    #
+    # @param [Cookbook]
+    #   the cookbook to run this filter against
+    #
+    def run(cookbook, options = {})
+      log.info(message)
+      instance = klass.new(cookbook, options)
+
+      inside(cookbook) do
+        instance.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/stove/jira.rb

@@ -1,43 +1,87 @@
-require 'jiralicious'
-require 'json'
+require 'faraday'
+require 'faraday_middleware'
 
 module Stove
   class JIRA
-    JIRA_URL = 'https://tickets.opscode.com'
+    include Mixin::Instanceable
+    include Mixin::Loggable
+    include Mixin::Optionable
 
-    Jiralicious.configure do |config|
-      config.username = Stove::Config['jira_username']
-      config.password = Stove::Config['jira_password']
-      config.uri      = JIRA_URL
+    option :base_url,
+      ENV['JIRA_URL'] || 'https://tickets.opscode.com/rest/api/2'
+
+    def issue(key, options = {})
+      connection.get("issue/#{key}", options).body
+    end
+
+    def search(query = {})
+      jql = query.map { |k,v| %Q|#{k} = "#{v}"| }.join(' AND ')
+      connection.get('search', jql: jql).body
     end
 
-    class << self
-      def unreleased_tickets_for(component)
-        jql = [
-          'project = COOK',
-          'resolution = Fixed',
-          'status = "Fix Committed"',
-          'component = ' + component.inspect
-        ].join(' AND ')
-        Stove::Logger.debug "JQL: #{jql.inspect}"
-
-        Jiralicious.search(jql).issues
+    def close_and_comment(key, comment)
+      transitions = issue(key, expand: 'transitions')['transitions']
+      close = transitions.first { |transition| transition['name'] == 'Close' }
+
+      if close.nil?
+        log.warn("Issue #{key} does not have a `Close' transition")
+        return
       end
 
-      # Comment and close a particular issue.
-      #
-      # @param [Jiralicious::Issue] ticket
-      #   the JIRA ticket
-      # @param [Stove::Cookbook] cookbook
-      #   the cookbook to release
-      def comment_and_close(ticket, cookbook)
-        comment = "Released in [#{cookbook.version}|#{cookbook.url}]"
+      connection.post("issue/#{key}/transitions", {
+        transition: { id: close['id'] },
+        update: {
+          comment: [
+            { add: { body: comment.to_s } }
+          ]
+        },
+        fields: {
+          resolution: {
+            name: 'Fixed'
+          },
+          assignee: {
+            name: nil
+          }
+        }
+      })
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(base_url) do |builder|
+        # Encode request bodies as JSON
+        builder.request :json
+
+        # Add basic authentication information
+        builder.request :basic_auth, Stove::Config[:jira][:username],
+                                     Stove::Config[:jira][:password]
+
+        # Handle any common errors
+        builder.use Stove::Middleware::Exceptions
+
+        # Decode responses as JSON if the Content-Type is json
+        builder.response :json
+        builder.response :json_fix
+
+        # Allow up to 3 redirects
+        builder.response :follow_redirects, limit: 3
+
+        # Log all requests and responses (useful for development)
+        builder.response :logger, log
+
+        # Raise errors on 40x and 50x responses
+        builder.response :raise_error
+
+        # Use the default adapter (Net::HTTP)
+        builder.adapter :net_http
 
-        transition = Jiralicious::Issue::Transitions.find(ticket.jira_key).find do |key, value|
-          !value.is_a?(String) && value.name == 'Close'
-        end.last
+        # Set the User-Agent header for logging purposes
+        builder.headers[:user_agent] = Stove::USER_AGENT
 
-        Jiralicious::Issue::Transitions.go(ticket.jira_key, transition.id, { comment: comment })
+        # Set some options, such as timeouts
+        builder.options[:timeout]      = 30
+        builder.options[:open_timeout] = 30
       end
     end
   end

data/lib/stove/middlewares/chef_authentication.rb

@@ -0,0 +1,60 @@
+require 'pp'
+
+module Stove
+  class Middleware::ChefAuthentication < Faraday::Middleware
+    dependency do
+      require 'mixlib/authentication/signedheaderauth'
+      require 'openssl'
+      require 'uri'
+    end
+
+    #
+    # @param [Faraday::Application] app
+    # @param [String] client
+    #   the name of the client to use for Chef
+    # @param [OpenSSL::PKey::RSA] key
+    #   the RSA private key to sign with
+    #
+    def initialize(app, client, key)
+      super(app)
+
+      @client = client
+      @key    = OpenSSL::PKey::RSA.new(File.read(key))
+    end
+
+    def call(env)
+      env[:request_headers].merge!(signing_object(env))
+      @app.call(env)
+    end
+
+    private
+
+    def signing_object(env)
+      params = {
+        :http_method => env[:method],
+        :timestamp   => Time.now.utc.iso8601,
+        :user_id     => @client,
+        :path        => env[:url].path,
+        :body        => env[:body] || '',
+      }
+
+      # Royal fucking hack
+      #   1. (n.) This code sample
+      #   2. (v.) Having to decompose a Faraday response because Mixlib
+      #           Authentication couldn't get a date to the prom
+      if env[:body] && env[:body].is_a?(Faraday::CompositeReadIO)
+        file = env[:body]
+          .instance_variable_get(:@parts)
+          .first { |part| part.is_a?(Faraday::Parts::FilePart) }
+          .instance_variable_get(:@io)
+          .instance_variable_get(:@ios)[1]
+          .instance_variable_get(:@local_path)
+
+        params[:file] = File.new(file)
+      end
+
+      object = Mixlib::Authentication::SignedHeaderAuth.signing_object(params)
+      object.sign(@key)
+    end
+  end
+end

data/lib/stove/middlewares/exceptions.rb

@@ -0,0 +1,17 @@
+module Stove
+  class Middleware::Exceptions < Faraday::Middleware
+    include Mixin::Loggable
+
+    def call(env)
+      begin
+        @app.call(env)
+      rescue Faraday::Error::ConnectionFailed
+        url = env[:url].to_s.gsub(env[:url].path, '')
+        raise Error::ServerUnavailable.new(url: url)
+      rescue Faraday::Error::ClientError => e
+        log.debug(env.inspect)
+        raise
+      end
+    end
+  end
+end

data/lib/stove/mixins/filterable.rb

@@ -0,0 +1,11 @@
+module Stove
+  module Mixin::Filterable
+    def before(action, message, &block)
+      Runner.filters[action][:before] << Filter.new(self, message, &block)
+    end
+
+    def after(action, message, &block)
+      Runner.filters[action][:after] << Filter.new(self, message, &block)
+    end
+  end
+end