license-acceptance 0.2.10 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa15a0ed3a76f4f1bd60469de0b9f836f73f7db824da061e876bd95fb78a919b
-  data.tar.gz: d31a667d3f45ed4455e613d6091f3635aeb6f76cfd40589f0a35e6108d022847
+  metadata.gz: e892e857adb140ddab6c76d173116f248180ced44a2e2ceeeecd9919b1a91b09
+  data.tar.gz: ce171bdadb89755fa39e0bd9ce5c5c63901d7949958a0de9a4883a823a35ae9f
 SHA512:
-  metadata.gz: 0a91aee2c874863a1bb217da59b9cf9f8345cc90f2f9e6e9420ca9bb792fbca3808a23131702b434a64321ae915c4973b640dd71d3b0da65002c456c56e14f1d
-  data.tar.gz: 76433d31718bffa392e817f7a350aab605142dc5d2248c25f0349adde3ac23c0ce36f83130296900dd84b24a600049df04e4c3e8a325154446540dae0e7fbb0c
+  metadata.gz: 0a6c4bb643dc44b5ca0ca0e0f48f6ac22ef590bc7645eea104aa584259d29a911054030749689d2be4424daed5d5a6fd2ace9554a2c7ee9989502d7f63e69d79
+  data.tar.gz: c5508cb4655eb0a02ba5c1067b9c58a8c03a08d9ff9eeed7bf0c864df31749ab649901db64c5fc3db6da1fee22f66c81e0bc27d32b02a0fc4899648033c2f408

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    license-acceptance (0.2.10)
+    license-acceptance (1.0.5)
       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/config/product_info.toml

@@ -2,27 +2,36 @@
 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"
 
 [relationships]
-"chef-client" = ["inspec"]
+"infra-client" = ["inspec"]
+"infra-server" = ["infra-client"]
+"push-jobs-server" = ["infra-client", "infra-server"]

data/lib/license_acceptance/acceptor.rb

@@ -3,26 +3,35 @@ 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"
+  ACCEPT_SILENT = "accept-silent"
+  ACCEPT_NO_PERSIST = "accept-no-persist"
+
   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)
+      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,73 +39,102 @@ 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
+      elsif config.output.isatty && prompt_strategy.request(missing_licenses) do
+          # We have to infer the acceptance value if they use the prompt to accept
           if config.persist
-            file_acceptance.persist(product_relationship, missing_licenses)
+            @acceptance_value = ACCEPT
+            file_strategy.persist(product_relationship, missing_licenses)
           else
+            @acceptance_value = ACCEPT_NO_PERSIST
             []
           end
         end
         return true
       else
-        raise LicenseNotAcceptedError.new(missing_licenses)
+        raise LicenseNotAcceptedError.new(product_relationship.parent, missing_licenses)
       end
     end
 
-    def self.check_and_persist!(product_name, version, opts={})
-      new(opts).check_and_persist!(product_name, version)
+    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
+
+    # 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
+      return true if version == :latest || 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
 
     # In the case where users accept with a command line argument or environment variable
@@ -104,26 +142,28 @@ 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
 
   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/product.rb

@@ -1,19 +1,24 @@
 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 &&
+      if other.id == id &&
          other.pretty_name == pretty_name &&
-         other.filename == filename
+         other.filename == filename &&
+         other.mixlib_name == mixlib_name
+         other.license_required_version == license_required_version
          return true
       end
       return false

data/lib/license_acceptance/product_reader.rb

@@ -19,20 +19,24 @@ module LicenseAcceptance
       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"])
+        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?
+      for parent_id, children in toml["relationships"]
+        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
@@ -51,9 +55,9 @@ module LicenseAcceptance
       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
@@ -62,6 +66,13 @@ module LicenseAcceptance
       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 +105,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,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,7 @@
+module LicenseAcceptance
+  module Strategy
+    class Base
+
+    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,103 @@
+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(&:id)}")
+
+        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(&:id)}")
+        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.pretty_name} at path #{path}")
+        ::File.open(path, ::File::WRONLY | ::File::CREAT | ::File::EXCL) do |license_file|
+          contents = {
+            id: product.id,
+            name: product.pretty_name,
+            date_accepted: INVOCATION_TIME.iso8601,
+            accepting_product: parent.id,
+            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