license-acceptance 0.2.10 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa15a0ed3a76f4f1bd60469de0b9f836f73f7db824da061e876bd95fb78a919b
-  data.tar.gz: d31a667d3f45ed4455e613d6091f3635aeb6f76cfd40589f0a35e6108d022847
+  metadata.gz: d82f01f1176a863816de18e547817c501d796873019601fc84a6c01a2e97c713
+  data.tar.gz: eab594e87a7613d6126e124757f63f2acc35fcbf24485a50d84e96f2609c6f51
 SHA512:
-  metadata.gz: 0a91aee2c874863a1bb217da59b9cf9f8345cc90f2f9e6e9420ca9bb792fbca3808a23131702b434a64321ae915c4973b640dd71d3b0da65002c456c56e14f1d
-  data.tar.gz: 76433d31718bffa392e817f7a350aab605142dc5d2248c25f0349adde3ac23c0ce36f83130296900dd84b24a600049df04e4c3e8a325154446540dae0e7fbb0c
+  metadata.gz: c9ed6dd65f3fb274f110157fab725a9b2cc0b341aff313f38a4a30809fd19aaef0dd52d9eabeb95a8f1738c45fff0f3efdf39a9d681fb4b9ed3118b0eeb0090e
+  data.tar.gz: 3fe1ba49289e95c77ffc863deea1221bd418cb5a111262904349d4c92e3dc2a5a760e5c562175d0a167916c3f028bcf8d0a346e038e8b935a69aadc6d147f3f6

data/Gemfile

@@ -1,6 +1,28 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in license-acceptance.gemspec
 gemspec
+
+group :development do
+  gem "chefstyle", "1.3.2"
+  gem "climate_control", "~> 0.2"
+  gem "mixlib-cli", "~> 2.1"
+  gem "rake", ">= 10.1.0"
+  gem "rspec", "~> 3.0"
+  gem "thor", ">= 0.20", "< 2.0" # validate 2.0 when it ships
+end
+
+group :docs do
+  gem "yard"
+  gem "redcarpet"
+  gem "github-markup"
+end
+
+group :debug do
+  gem "pry"
+  gem "pry-byebug"
+  gem "pry-stack_explorer", "~> 0.4.0" # pin until we drop ruby < 2.6
+  gem "rb-readline"
+end

data/config/product_info.toml

@@ -2,27 +2,58 @@
 title = "All known products that require license acceptance, and the mapping of parent to child relationships"
 
 [[products]]
-name = "chef-client"
-pretty_name = "Chef Client"
+id = "infra-client"
+pretty_name = "Chef Infra Client"
 hab_pkg_id = "chef/chef-client"
-filename = "chef_client"
+filename = "chef_infra_client"
+mixlib_name = "chef"
+license_required_version = "15"
 
 [[products]]
-name = "inspec"
-pretty_name = "InSpec"
+id = "inspec"
+pretty_name = "Chef InSpec"
 hab_pkg_id = "chef/inspec"
 filename = "inspec"
 
 [[products]]
-name = "supermarket"
+id = "supermarket"
 pretty_name = "Supermarket"
 filename = "supermarket"
 
 [[products]]
-name = "chef-server"
-pretty_name = "Chef Server"
+id = "infra-server"
+pretty_name = "Chef Infra Server"
 hab_pkg_id = "chef/oc_erchef"
-filename = "chef_server"
+filename = "chef_infra_server"
+
+[[products]]
+id = "push-jobs-server"
+pretty_name = "Chef Push Jobs Server"
+filename = "push_jobs_server"
+
+[[products]]
+id = "push-jobs-client"
+pretty_name = "Chef Push Jobs Client"
+filename = "push_jobs_client"
+
+[[products]]
+id = "chef-dk"
+pretty_name = "Chef Development Kit"
+filename = "chef_dk"
+mixlib_name = "chefdk"
+license_required_version = "4"
+
+[[products]]
+id = "chef-workstation"
+pretty_name = "Chef Workstation"
+filename = "chef_workstation"
+mixlib_name = "chef-workstation"
+license_required_version = "0.4"
 
 [relationships]
-"chef-client" = ["inspec"]
+"infra-client" = ["inspec"]
+"infra-server" = ["infra-client", "inspec"]
+"push-jobs-server" = ["infra-client", "infra-server"]
+"push-jobs-client" = ["infra-client"]
+"chef-dk" = ["infra-client", "inspec"]
+"chef-workstation" = ["infra-client", "inspec"]

data/lib/license_acceptance/acceptor.rb

@@ -1,28 +1,37 @@
-require "forwardable"
+require "forwardable" unless defined?(Forwardable)
 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
+
+  ACCEPT = "accept".freeze
+  ACCEPT_SILENT = "accept-silent".freeze
+  ACCEPT_NO_PERSIST = "accept-no-persist".freeze
+
   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={})
+    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)
+      product_reader.read
+      @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))
+      @acceptance_value = nil
     end
 
     def_delegator :@config, :output
@@ -30,100 +39,148 @@ module LicenseAcceptance
     # For applications that just need simple logic to handle a failed license acceptance flow we include this small
     # wrapper. Apps with more complex logic (like logging to a logging engine) should call the non-bang version and
     # handle the exception.
-    def check_and_persist!(product_name, version)
-      check_and_persist(product_name, version)
-    rescue LicenseNotAcceptedError
-      output.puts "#{product_name} cannot execute without accepting the license"
+    def check_and_persist!(product_id, version)
+      check_and_persist(product_id, version)
+    rescue LicenseNotAcceptedError => e
+      output.puts "#{e.product.pretty_name} cannot execute without accepting the license"
       exit 172
     end
 
-    def check_and_persist(product_name, version)
+    def check_and_persist(product_id, version)
       if accepted_no_persist?
         logger.debug("Chef License accepted with no persistence")
+        @acceptance_value = ACCEPT_NO_PERSIST
         return true
       end
 
-      product_reader.read
-      product_relationship = product_reader.lookup(product_name, version)
+      product_relationship = product_reader.lookup(product_id, 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?
         logger.debug("All licenses present")
+        @acceptance_value = ACCEPT
         return true
       end
 
       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
             output_persist_failed(errs)
           end
         end
+        @acceptance_value = accepted_silent? ? ACCEPT_SILENT : ACCEPT
         return true
-      elsif config.output.isatty && prompt_acceptance.request(missing_licenses) do
-          if config.persist
-            file_acceptance.persist(product_relationship, missing_licenses)
-          else
-            []
-          end
+      end
+
+      if acceptance_value_provided?
+        value = provided_strategy.value || env_strategy.value || arg_strategy.value
+        output.puts("Unrecognized license acceptance value '#{value}', expected one of: '#{ACCEPT}', '#{ACCEPT_SILENT}', '#{ACCEPT_NO_PERSIST}'")
+        raise LicenseNotAcceptedError.new(product_relationship.parent, missing_licenses)
+      end
+
+      return true if output.isatty && accepted_license_prompt?(product_relationship, missing_licenses)
+
+      raise LicenseNotAcceptedError.new(product_relationship.parent, missing_licenses)
+    end
+
+    def self.check_and_persist!(product_id, version, opts = {})
+      new(opts).check_and_persist!(product_id, version)
+    end
+
+    def self.check_and_persist(product_id, version, opts = {})
+      new(opts).check_and_persist(product_id, version)
+    end
+
+    def accepted_license_prompt?(product_relationship, missing_licenses)
+      prompt_strategy.request(missing_licenses) do
+        # We have to infer the acceptance value if they use the prompt to accept
+        if config.persist
+          @acceptance_value = ACCEPT
+          file_strategy.persist(product_relationship, missing_licenses)
+        else
+          @acceptance_value = ACCEPT_NO_PERSIST
+          []
         end
-        return true
-      else
-        raise LicenseNotAcceptedError.new(missing_licenses)
       end
     end
 
-    def self.check_and_persist!(product_name, version, opts={})
-      new(opts).check_and_persist!(product_name, version)
+    # Check whether the specified product requires license acceptance for the given version.
+    def license_required?(mixlib_name, version)
+      product = product_reader.lookup_by_mixlib(mixlib_name)
+      return false if product.nil?
+      # If they don't pass a version we assume they want latest
+      # All versions in all channels require license acceptance
+      return true if %w{latest unstable current stable}.include?(version.to_s) || version.nil?
+
+      Gem::Version.new(version) >= Gem::Version.new(product.license_required_version)
+    end
+
+    # Some callers only know about mixlib names so we need a way for them to get the product
+    # id as this library knows it.
+    def id_from_mixlib(mixlib_name)
+      product = product_reader.lookup_by_mixlib(mixlib_name)
+      return nil if product.nil?
+
+      product.id
     end
 
-    def self.check_and_persist(product_name, version, opts={})
-      new(opts).check_and_persist(product_name, version)
+    # Return the value that was matched ("accept", "accept-no-persist", etc.). Used by callers so they do not
+    # have to know the precedence order between provided/environment/argument. Can just get back the value
+    # that was used. Value is only guaranteed to be set after calling check_and_persist.
+    def acceptance_value
+      @acceptance_value
     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
+
+    def acceptance_value_provided?
+      provided_strategy.value? || env_strategy.value? || arg_strategy.value?
     end
 
     # In the case where users accept with a command line argument or environment variable
     # we still want to output the fact that the filesystem was changed.
     def output_num_persisted(count)
-      s = count > 1 ? "s": ""
+      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.
-      Could not persist acceptance:\n\t* #{errs.map(&:message).join("\n\t* ")}
-      #{PromptAcceptance::BORDER}
+        #{Strategy::Prompt::BORDER}
+        #{Strategy::Prompt::CHECK} Product license accepted.
+        Could not persist acceptance:\n\t* #{errs.map(&:message).join("\n\t* ")}
+        #{Strategy::Prompt::BORDER}
       EOM
     end
 
   end
 
   class LicenseNotAcceptedError < RuntimeError
-    def initialize(missing_licenses)
-      msg = "Missing licenses for the following:\n* " + missing_licenses.join("\n* ")
+    attr_reader :product
+    def initialize(product, missing_licenses)
+      @product = product
+      msg = "Missing licenses for the following:\n* " + missing_licenses.map(&:id).join("\n* ")
       super(msg)
     end
   end

data/lib/license_acceptance/cli_flags/mixlib_cli.rb

@@ -1,6 +1,6 @@
 begin
-  require 'mixlib/cli'
-rescue => exception
+  require "mixlib/cli" unless defined?(Mixlib::CLI)
+rescue
   raise "Must have mixlib-cli gem installed to use this mixin"
 end
 

data/lib/license_acceptance/cli_flags/thor.rb

@@ -1,6 +1,6 @@
 begin
-  require 'thor'
-rescue => exception
+  require "thor" unless defined?(Thor)
+rescue
   raise "Must have thor gem installed to use this mixin"
 end
 
@@ -12,7 +12,7 @@ module LicenseAcceptance
       def self.included(klass)
         klass.class_option :chef_license,
           type: :string,
-          desc: 'Accept the license for this product and any contained products: accept, accept-no-persist, accept-silent'
+          desc: "Accept the license for this product and any contained products: accept, accept-no-persist, accept-silent"
       end
 
     end

data/lib/license_acceptance/config.rb

@@ -1,10 +1,10 @@
-require 'logger'
+require "logger"
 
 module LicenseAcceptance
   class Config
     attr_accessor :output, :logger, :license_locations, :persist_location, :persist
 
-    def initialize(opts={})
+    def initialize(opts = {})
       @output = opts.fetch(:output, $stdout)
       @logger = opts.fetch(:logger, ::Logger.new(IO::NULL))
       @license_locations = opts.fetch(:license_locations, default_license_locations)
@@ -21,7 +21,8 @@ module LicenseAcceptance
 
     def default_license_locations
       if windows?
-        l = [ File.join(ENV["HOMEDRIVE"], "chef/accepted_licenses/") ]
+        root = ENV.fetch("SYSTEMDRIVE", "C:")
+        l = [ File.join(root, "chef/accepted_licenses/") ]
         unless is_root?
           # Look through a list of possible user locations and pick the first one that exists
           # copied from path_helper.rb in chef-config gem
@@ -31,6 +32,7 @@ module LicenseAcceptance
           possible_dirs << ENV["HOMESHARE"] + ENV["HOMEPATH"] if ENV["HOMESHARE"] && ENV["HOMEPATH"]
           possible_dirs << ENV["USERPROFILE"] if ENV["USERPROFILE"]
           raise NoValidEnvironmentVar if possible_dirs.empty?
+
           possible_dirs.each do |possible_dir|
             if Dir.exist?(possible_dir)
               full_possible_dir = File.join(possible_dir, ".chef/accepted_licenses/")
@@ -41,7 +43,7 @@ module LicenseAcceptance
         end
       else
         l = [ "/etc/chef/accepted_licenses/" ]
-        l << File.join(ENV['HOME'], ".chef/accepted_licenses/") unless is_root?
+        l << File.join(ENV["HOME"], ".chef/accepted_licenses/") unless is_root?
       end
       l
     end

data/lib/license_acceptance/product.rb

@@ -1,22 +1,29 @@
 module LicenseAcceptance
   class Product
 
-    attr_reader :name, :pretty_name, :filename
+    attr_reader :id, :pretty_name, :filename, :mixlib_name, :license_required_version
 
-    def initialize(name, pretty_name, filename)
-      @name = name
+    def initialize(id, pretty_name, filename, mixlib_name, license_required_version)
+      # id is the internal representation of this product as license-acceptance knows it
+      @id = id
       @pretty_name = pretty_name
       @filename = filename
+      @mixlib_name = mixlib_name
+      @license_required_version = license_required_version
     end
 
     def ==(other)
       return false if other.class != Product
-      if other.name == name &&
-         other.pretty_name == pretty_name &&
-         other.filename == filename
-         return true
+
+      if other.id == id &&
+          other.pretty_name == pretty_name &&
+          other.filename == filename &&
+          other.mixlib_name == mixlib_name &&
+          other.license_required_version == license_required_version
+        return true
       end
-      return false
+
+      false
     end
 
   end

data/lib/license_acceptance/product_reader.rb

@@ -1,4 +1,4 @@
-require "tomlrb"
+autoload :Tomlrb, "tomlrb"
 require "license_acceptance/logger"
 require "license_acceptance/product"
 require "license_acceptance/product_relationship"
@@ -18,21 +18,27 @@ module LicenseAcceptance
       toml = Tomlrb.load_file(location, symbolize_keys: false)
       raise InvalidProductInfo.new(location) if toml.empty? || toml["products"].nil? || toml["relationships"].nil?
 
-      for product in toml["products"]
-        products[product["name"]] = Product.new(product["name"], product["pretty_name"], product["filename"])
+      toml["products"].each do |product|
+        products[product["id"]] = Product.new(
+          product["id"], product["pretty_name"],
+          product["filename"], product["mixlib_name"],
+          product["license_required_version"]
+        )
       end
 
-      for parent_name, children in toml["relationships"]
-        parent = products[parent_name]
-        raise UnknownParent.new(parent_name) if parent.nil?
+      toml["relationships"].each do |parent_id, children|
+        parent = products[parent_id]
+        raise UnknownParent.new(parent_id) if parent.nil?
         # Its fine to not have a relationship entry, but not fine to have
         # a relationship where the children are nil or empty.
         if children.nil? || children.empty? || !children.is_a?(Array)
           raise NoChildRelationships.new(parent)
         end
-        children.map! do |child_name|
-          child = products[child_name]
-          raise UnknownChild.new(child_name) if child.nil?
+
+        children.map! do |child_id|
+          child = products[child_id]
+          raise UnknownChild.new(child_id) if child.nil?
+
           child
         end
         relationships[parent] = children
@@ -48,20 +54,29 @@ module LicenseAcceptance
       if ENV["CHEF_LICENSE_PRODUCT_INFO"]
         return ENV["CHEF_LICENSE_PRODUCT_INFO"]
       end
+
       File.absolute_path(File.join(__FILE__, "../../../config/product_info.toml"))
     end
 
-    def lookup(parent_name, parent_version)
-      parent_product = products.fetch(parent_name) do
-        raise UnknownProduct.new(parent_name)
+    def lookup(parent_id, parent_version)
+      parent_product = products.fetch(parent_id) do
+        raise UnknownProduct.new(parent_id)
       end
       children = relationships.fetch(parent_product, [])
-      if !parent_version.is_a? String
+      unless parent_version.is_a? String
         raise ProductVersionTypeError.new(parent_version)
       end
+
       ProductRelationship.new(parent_product, children, parent_version)
     end
 
+    def lookup_by_mixlib(mixlib_name)
+      found_product = products.values.find(nil) do |p|
+        p.mixlib_name == mixlib_name
+      end
+      found_product
+    end
+
   end
 
   class UnknownProduct < RuntimeError
@@ -94,7 +109,7 @@ module LicenseAcceptance
 
   class NoChildRelationships < RuntimeError
     def initialize(product)
-      msg = "No child relationships for #{product.name}, should be removed from product info or fixed"
+      msg = "No child relationships for #{product.id}, should be removed from product info or fixed"
       super(msg)
     end
   end

data/lib/license_acceptance/strategy/argument.rb

@@ -0,0 +1,45 @@
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Look for acceptance values in the ARGV
+    class Argument < Base
+
+      FLAG = "--chef-license".freeze
+
+      attr_reader :argv
+
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def accepted?
+        String(value).downcase == ACCEPT
+      end
+
+      def silent?
+        String(value).downcase == ACCEPT_SILENT
+      end
+
+      def no_persist?
+        String(value).downcase == ACCEPT_NO_PERSIST
+      end
+
+      def value?
+        argv.any? { |s| s == FLAG || s.start_with?("#{FLAG}=") }
+      end
+
+      def value
+        match = argv.detect { |s| s.start_with?("#{FLAG}=") }
+        return match.split("=").last if match
+
+        argv.each_cons(2) do |arg, value|
+          return value if arg == FLAG
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/license_acceptance/strategy/base.rb

@@ -0,0 +1,7 @@
+module LicenseAcceptance
+  module Strategy
+    class Base
+
+    end
+  end
+end

data/lib/license_acceptance/strategy/environment.rb

@@ -0,0 +1,39 @@
+require "license_acceptance/strategy/base"
+
+module LicenseAcceptance
+  module Strategy
+
+    # Look for acceptance values in the environment
+    class Environment < Base
+
+      ENV_KEY = "CHEF_LICENSE".freeze
+
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def accepted?
+        String(value).downcase == ACCEPT
+      end
+
+      def silent?
+        String(value).downcase == ACCEPT_SILENT
+      end
+
+      def no_persist?
+        String(value).downcase == ACCEPT_NO_PERSIST
+      end
+
+      def value?
+        env.key?(ENV_KEY)
+      end
+
+      def value
+        env[ENV_KEY]
+      end
+
+    end
+  end
+end