license-acceptance 0.2.10 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa15a0ed3a76f4f1bd60469de0b9f836f73f7db824da061e876bd95fb78a919b
-  data.tar.gz: d31a667d3f45ed4455e613d6091f3635aeb6f76cfd40589f0a35e6108d022847
+  metadata.gz: a4e838f450a28b5543cbf2ebf0a620b4274567cc1f42067d2ebd859a5e122005
+  data.tar.gz: 6257b8dd5964e8058e7614c219ebbe60234f9f060dff4c52cdd4df3a295daecb
 SHA512:
-  metadata.gz: 0a91aee2c874863a1bb217da59b9cf9f8345cc90f2f9e6e9420ca9bb792fbca3808a23131702b434a64321ae915c4973b640dd71d3b0da65002c456c56e14f1d
-  data.tar.gz: 76433d31718bffa392e817f7a350aab605142dc5d2248c25f0349adde3ac23c0ce36f83130296900dd84b24a600049df04e4c3e8a325154446540dae0e7fbb0c
+  metadata.gz: 81e308d0664299c9797fa0b06470f550aac3087f9d154ee0f8b3737aff4cfc09fca669a80f81d4be726d01e4166124ea3747630720f32d8115bc1c5d5fb38722
+  data.tar.gz: 3677568ac06e369235ecba67c6ae38cd4f271a9ca19f495c8d2e789e32e18eea559fe40aea9a8f1b60cdef659828f5b892eacf1c70099ea83cae1b846bd27cf1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    license-acceptance (0.2.10)
+    license-acceptance (0.2.13)
       pastel (~> 0.7)
       tomlrb (~> 1.2)
       tty-box (~> 0.3)
@@ -40,7 +40,7 @@ GEM
       rspec-mocks (~> 3.8.0)
     rspec-core (3.8.0)
       rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.2)
+    rspec-expectations (3.8.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-mocks (3.8.0)

data/lib/license_acceptance/acceptor.rb

@@ -3,26 +3,28 @@ require "license_acceptance/config"
 require "license_acceptance/logger"
 require "license_acceptance/product_reader"
 require "license_acceptance/product_relationship"
-require "license_acceptance/file_acceptance"
-require "license_acceptance/arg_acceptance"
-require "license_acceptance/prompt_acceptance"
-require "license_acceptance/env_acceptance"
+require "license_acceptance/strategy/environment"
+require "license_acceptance/strategy/file"
+require "license_acceptance/strategy/argument"
+require "license_acceptance/strategy/prompt"
+require "license_acceptance/strategy/provided_value"
 
 module LicenseAcceptance
   class Acceptor
     extend Forwardable
     include Logger
 
-    attr_reader :config, :product_reader, :env_acceptance, :file_acceptance, :arg_acceptance, :prompt_acceptance
+    attr_reader :config, :product_reader, :env_strategy, :file_strategy, :arg_strategy, :prompt_strategy, :provided_strategy
 
     def initialize(opts={})
       @config = Config.new(opts)
       Logger.initialize(config.logger)
       @product_reader = ProductReader.new
-      @env_acceptance = EnvAcceptance.new
-      @file_acceptance = FileAcceptance.new(config)
-      @arg_acceptance = ArgAcceptance.new
-      @prompt_acceptance = PromptAcceptance.new(config)
+      @env_strategy = Strategy::Environment.new(ENV)
+      @file_strategy = Strategy::File.new(config)
+      @arg_strategy = Strategy::Argument.new(ARGV)
+      @prompt_strategy = Strategy::Prompt.new(config)
+      @provided_strategy = Strategy::ProvidedValue.new(opts.fetch(:provided, nil))
     end
 
     def_delegator :@config, :output
@@ -46,7 +48,7 @@ module LicenseAcceptance
       product_reader.read
       product_relationship = product_reader.lookup(product_name, version)
 
-      missing_licenses = file_acceptance.accepted?(product_relationship)
+      missing_licenses = file_strategy.accepted?(product_relationship)
 
       # They have already accepted all licenses and stored their acceptance in the persistent files
       if missing_licenses.empty?
@@ -56,7 +58,7 @@ module LicenseAcceptance
 
       if accepted? || accepted_silent?
         if config.persist
-          errs = file_acceptance.persist(product_relationship, missing_licenses)
+          errs = file_strategy.persist(product_relationship, missing_licenses)
           if errs.empty?
             output_num_persisted(missing_licenses.size) unless accepted_silent?
           else
@@ -64,9 +66,9 @@ module LicenseAcceptance
           end
         end
         return true
-      elsif config.output.isatty && prompt_acceptance.request(missing_licenses) do
+      elsif config.output.isatty && prompt_strategy.request(missing_licenses) do
           if config.persist
-            file_acceptance.persist(product_relationship, missing_licenses)
+            file_strategy.persist(product_relationship, missing_licenses)
           else
             []
           end
@@ -86,17 +88,17 @@ module LicenseAcceptance
     end
 
     def accepted?
-      env_acceptance.accepted?(ENV) || arg_acceptance.accepted?(ARGV)
+      provided_strategy.accepted? || env_strategy.accepted? || arg_strategy.accepted?
     end
 
     # no-persist is silent too
     def accepted_no_persist?
-      env_acceptance.no_persist?(ENV) || arg_acceptance.no_persist?(ARGV)
+      provided_strategy.no_persist? || env_strategy.no_persist? || arg_strategy.no_persist?
     end
 
     # persist but be silent like no-persist
     def accepted_silent?
-      env_acceptance.silent?(ENV) || arg_acceptance.silent?(ARGV)
+      provided_strategy.silent? || env_strategy.silent? || arg_strategy.silent?
     end
 
     # In the case where users accept with a command line argument or environment variable
@@ -104,18 +106,18 @@ module LicenseAcceptance
     def output_num_persisted(count)
       s = count > 1 ? "s": ""
       output.puts <<~EOM
-      #{PromptAcceptance::BORDER}
-      #{PromptAcceptance::CHECK} #{count} product license#{s} accepted.
-      #{PromptAcceptance::BORDER}
+      #{Strategy::Prompt::BORDER}
+      #{Strategy::Prompt::CHECK} #{count} product license#{s} accepted.
+      #{Strategy::Prompt::BORDER}
       EOM
     end
 
     def output_persist_failed(errs)
       output.puts <<~EOM
-      #{PromptAcceptance::BORDER}
-      #{PromptAcceptance::CHECK} Product license accepted.
+      #{Strategy::Prompt::BORDER}
+      #{Strategy::Prompt::CHECK} Product license accepted.
       Could not persist acceptance:\n\t* #{errs.map(&:message).join("\n\t* ")}
-      #{PromptAcceptance::BORDER}
+      #{Strategy::Prompt::BORDER}
       EOM
     end
 

data/lib/license_acceptance/strategy/argument.rb

@@ -0,0 +1,44 @@
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Look for acceptance values in the ARGV
+    class Argument < Base
+
+      attr_reader :argv
+
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def accepted?
+        look_for_value(ACCEPT)
+      end
+
+      def silent?
+        look_for_value(ACCEPT_SILENT)
+      end
+
+      def no_persist?
+        look_for_value(ACCEPT_NO_PERSIST)
+      end
+
+      private
+
+      def look_for_value(sought)
+        if argv.include?("--chef-license=#{sought}")
+          return true
+        end
+        i = argv.index("--chef-license")
+        unless i.nil?
+          val = argv[i+1]
+          if val != nil && val.downcase == sought
+            return true
+          end
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/license_acceptance/strategy/base.rb

@@ -0,0 +1,11 @@
+module LicenseAcceptance
+  module Strategy
+    class Base
+
+      ACCEPT = "accept"
+      ACCEPT_SILENT = "accept-silent"
+      ACCEPT_NO_PERSIST = "accept-no-persist"
+
+    end
+  end
+end

data/lib/license_acceptance/strategy/environment.rb

@@ -0,0 +1,38 @@
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Look for acceptance values in the environment
+    class Environment < Base
+
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def accepted?
+        look_for_value(ACCEPT)
+      end
+
+      def silent?
+        look_for_value(ACCEPT_SILENT)
+      end
+
+      def no_persist?
+        look_for_value(ACCEPT_NO_PERSIST)
+      end
+
+      private
+
+      def look_for_value(sought)
+        if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == sought
+          return true
+        end
+        return false
+      end
+
+    end
+  end
+end

data/lib/license_acceptance/strategy/file.rb

@@ -0,0 +1,102 @@
+require 'date'
+require 'yaml'
+require 'fileutils'
+require 'etc'
+require "license_acceptance/logger"
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Read and write marker files that show acceptance.
+    class File < Base
+      include Logger
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      INVOCATION_TIME = DateTime.now.freeze
+
+      # For all the given products in the product set, search all possible locations for the
+      # license acceptance files.
+      def accepted?(product_relationship)
+        searching = [product_relationship.parent] + product_relationship.children
+        missing_licenses = searching.clone
+        logger.debug("Searching for the following licenses: #{missing_licenses.map(&:name)}")
+
+        searching.each do |product|
+          found = false
+          config.license_locations.each do |loc|
+            f = ::File.join(loc, product.filename)
+            if ::File.exist?(f)
+              found = true
+              logger.debug("Found license #{product.filename} at #{f}")
+              missing_licenses.delete(product)
+              break
+            end
+          end
+          break if missing_licenses.empty?
+        end
+        logger.debug("Missing licenses remaining: #{missing_licenses.map(&:name)}")
+        missing_licenses
+      end
+
+      def persist(product_relationship, missing_licenses)
+        parent = product_relationship.parent
+        parent_version = product_relationship.parent_version
+        root_dir = config.persist_location
+
+        if !Dir.exist?(root_dir)
+          begin
+            FileUtils.mkdir_p(root_dir)
+          rescue StandardError => e
+            msg = "Could not create license directory #{root_dir}"
+            logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+            return [e]
+          end
+        end
+
+        errs = []
+        if missing_licenses.include?(parent)
+          err = persist_license(root_dir, parent, parent, parent_version)
+          errs << err unless err.nil?
+        end
+        product_relationship.children.each do |child|
+          if missing_licenses.include?(child)
+            err = persist_license(root_dir, child, parent, parent_version)
+            errs << err unless err.nil?
+          end
+        end
+        return errs
+      end
+
+      private
+
+      def persist_license(folder_path, product, parent, parent_version)
+        path = ::File.join(folder_path, product.filename)
+        logger.info("Persisting a license for #{product.name} at path #{path}")
+        ::File.open(path, ::File::WRONLY | ::File::CREAT | ::File::EXCL) do |license_file|
+          contents = {
+            name: product.name,
+            date_accepted: INVOCATION_TIME.iso8601,
+            accepting_product: parent.name,
+            accepting_product_version: parent_version,
+            user: Etc.getlogin,
+            file_format: 1,
+          }
+          contents = Hash[contents.map { |k, v| [k.to_s, v] }]
+          license_file << YAML.dump(contents)
+        end
+        return nil
+      rescue StandardError => e
+        msg = "Could not persist license to #{path}"
+        logger.info "#{msg}\n\t#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+        return e
+      end
+
+    end
+  end
+end

data/lib/license_acceptance/strategy/prompt.rb

@@ -0,0 +1,111 @@
+require 'tty-prompt'
+require 'pastel'
+require "license_acceptance/logger"
+require "license_acceptance/strategy/base"
+require "timeout"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Interactive prompt for accepting and persistnce license acceptance, or failing with custom exit code
+    class Prompt < Base
+      include Logger
+
+      attr_reader :output
+
+      def initialize(config)
+        @output = config.output
+      end
+
+      WIDTH = 50.freeze
+      PASTEL = Pastel.new
+      BORDER = "+---------------------------------------------+".freeze
+      YES = PASTEL.green.bold("yes")
+      CHECK  = PASTEL.green("✔")
+
+      def request(missing_licenses, &persist_callback)
+        logger.debug("Requesting a license for #{missing_licenses.map(&:name)}")
+        c = missing_licenses.size
+        s = c > 1 ? "s": ""
+
+        acceptance_question = "Do you accept the #{c} product license#{s} (#{YES}/no)?"
+        output.puts <<~EOM
+        #{BORDER}
+                    Chef License Acceptance
+
+        Before you can continue, #{c} product license#{s}
+        must be accepted. View the license at
+        https://www.chef.io/end-user-license-agreement/
+
+        License#{s} that need accepting:
+          * #{missing_licenses.map(&:pretty_name).join("\n  * ")}
+
+        #{acceptance_question}
+
+        EOM
+
+        if ask(output, c, s, persist_callback)
+          output.puts BORDER
+          return true
+        end
+
+        output.puts <<~EOM
+
+        If you do not accept this license you will
+        not be able to use Chef products.
+
+        #{acceptance_question}
+
+        EOM
+
+        answer = ask(output, c, s, persist_callback)
+        if answer != "yes"
+          output.puts BORDER
+        end
+        return answer
+      end
+
+      private
+
+      def ask(output, c, s, persist_callback)
+        logger.debug("Attempting to request interactive prompt on TTY")
+        prompt = TTY::Prompt.new(track_history: false, active_color: :bold, interrupt: :exit, output: output)
+
+        answer = "no"
+        begin
+          Timeout::timeout(60, PromptTimeout) do
+            answer = prompt.ask(">") do |q|
+              q.modify :down, :trim
+              q.required true
+              q.messages[:required?] = "You must enter 'yes' or 'no'"
+              q.validate /^\s*(yes|no)\s*$/i
+              q.messages[:valid?] = "You must enter 'yes' or 'no'"
+            end
+          end
+        rescue PromptTimeout
+          prompt.unsubscribe(prompt.reader)
+          output.puts "Prompt timed out. Use non-interactive flags or enter an answer within 60 seconds."
+        end
+
+        if answer == "yes"
+          output.puts
+          output.puts "Persisting #{c} product license#{s}..."
+          errs = persist_callback.call
+          if errs.empty?
+            output.puts "#{CHECK} #{c} product license#{s} persisted.\n\n"
+          else
+            output.puts <<~EOM
+            #{CHECK} #{c} product license#{s} accepted.
+            Could not persist acceptance:\n\t* #{errs.map(&:message).join("\n\t* ")}
+            EOM
+          end
+          return true
+        end
+        return false
+      end
+    end
+
+    class PromptTimeout < StandardError; end
+
+  end
+end