license-acceptance 0.0.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7483f91b06d3f9eed8968382a03e5f2c7fb08448af51e42b0f104405e5339c22
-  data.tar.gz: a41ee7fdd79eca87e3f29db2b53963f1a2d8b8a4f12c1275b6f81065d05e2eb8
+  metadata.gz: 5ae4a25ff89f94b78498d69d0d5805a243e065cc2e622e4ec08f2acf8294345d
+  data.tar.gz: b994a62576a2e0c24694f916d3e4672f556077d8882bb52aa853706ef1e4e9c3
 SHA512:
-  metadata.gz: f93046a3fc6cf6eb2971bede8774e081aa3f398f919ad21009dfb3633286a98ddb7aabfd5632ee8fbdd923ce7667c4deace6407ffec8719930e9465ea3166025
-  data.tar.gz: 34374e8e941827e6773d6764b1e39fe3689e5c10241af067d8e49b985c7d2a891cfc4e8ba61c5bd5a2864d4572d6ba8f1e3417a60966d93ef850104a02f2680f
+  metadata.gz: c6d8d023638ba548846b92b27e166a7ff2683b96b59eb5513b71c28ebbd46792dfd755e46893409e02dfbf4ce83dcee28e60e4c26716078fbe122b465553d399
+  data.tar.gz: d4501d2b154e6fcf8dabdc1a40c689d2bb575ea09f0f61b1f3ccbb5775609808ac6543fc6f9ed9bbee262fc085ddc634ecc4f3732a01cc17e951422162fdcded

data/Gemfile

@@ -1,4 +1,6 @@
 source "https://rubygems.org"
 
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
 # Specify your gem's dependencies in license-acceptance.gemspec
 gemspec

data/Gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: .
+  specs:
+    license-acceptance (0.1.0)
+      pastel (>= 0.7)
+      tomlrb (~> 1.2)
+      tty-box (>= 0.3)
+      tty-platform (>= 0.2)
+      tty-prompt (>= 0.18)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    binding_of_caller (0.8.0)
+      debug_inspector (>= 0.0.1)
+    byebug (11.0.1)
+    climate_control (0.2.0)
+    coderay (1.1.2)
+    debug_inspector (0.0.3)
+    diff-lcs (1.3)
+    equatable (0.5.0)
+    method_source (0.9.2)
+    mixlib-cli (2.0.3)
+    necromancer (0.4.0)
+    pastel (0.7.2)
+      equatable (~> 0.5.0)
+      tty-color (~> 0.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
+      pry (~> 0.10)
+    pry-stack_explorer (0.4.9.3)
+      binding_of_caller (>= 0.7)
+      pry (>= 0.9.11)
+    rake (12.3.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    strings (0.1.4)
+      strings-ansi (~> 0.1.0)
+      unicode-display_width (~> 1.4.0)
+      unicode_utils (~> 1.4.0)
+    strings-ansi (0.1.0)
+    thor (0.20.3)
+    timers (4.3.0)
+    tomlrb (1.2.8)
+    tty-box (0.3.0)
+      pastel (~> 0.7.2)
+      strings (~> 0.1.4)
+      tty-cursor (~> 0.6.0)
+    tty-color (0.4.3)
+    tty-cursor (0.6.1)
+    tty-platform (0.2.0)
+    tty-prompt (0.18.1)
+      necromancer (~> 0.4.0)
+      pastel (~> 0.7.0)
+      timers (~> 4.0)
+      tty-cursor (~> 0.6.0)
+      tty-reader (~> 0.5.0)
+    tty-reader (0.5.0)
+      tty-cursor (~> 0.6.0)
+      tty-screen (~> 0.6.4)
+      wisper (~> 2.0.0)
+    tty-screen (0.6.5)
+    unicode-display_width (1.4.1)
+    unicode_utils (1.4.0)
+    wisper (2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.17)
+  climate_control (>= 0.2)
+  license-acceptance!
+  mixlib-cli (>= 1.7)
+  pry (>= 0.12)
+  pry-byebug (>= 3.6)
+  pry-stack_explorer (>= 0.4)
+  rake (>= 10.0)
+  rspec (>= 3.0)
+  thor (>= 0.20)
+
+BUNDLED WITH
+   1.17.3

data/config/product_info.toml

@@ -0,0 +1 @@
+# DO NOT CHANGE - overwritten by expeditor at build time

data/lib/license_acceptance/acceptor.rb

@@ -0,0 +1,117 @@
+require "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"
+
+module LicenseAcceptance
+  class Acceptor
+    extend Forwardable
+    include Logger
+
+    attr_reader :config, :product_reader, :env_acceptance, :file_acceptance, :arg_acceptance, :prompt_acceptance
+
+    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)
+    end
+
+    def_delegator :@config, :output
+
+    # 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"
+      exit 172
+    end
+
+    def check_and_persist(product_name, version)
+      if env_acceptance.check_no_persist(ENV) || arg_acceptance.check_no_persist(ARGV)
+        logger.debug("Chef License accepted with no persistence")
+        return true
+      end
+
+      product_reader.read
+      product_relationship = product_reader.lookup(product_name, version)
+
+      missing_licenses = file_acceptance.check(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")
+        return true
+      end
+
+      if env_acceptance.check(ENV) || arg_acceptance.check(ARGV)
+        if config.persist
+          errs = file_acceptance.persist(product_relationship, missing_licenses)
+          if errs.empty?
+            output_num_persisted(missing_licenses.size)
+          else
+            output_persist_failed(errs)
+          end
+        end
+        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
+        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)
+    end
+
+    def self.check_and_persist(product_name, version, opts={})
+      new(opts).check_and_persist(product_name, version)
+    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": ""
+      output.puts <<~EOM
+      #{PromptAcceptance::BORDER}
+      #{PromptAcceptance::CHECK} #{count} product license#{s} accepted.
+      #{PromptAcceptance::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}
+      EOM
+    end
+
+  end
+
+  class LicenseNotAcceptedError < RuntimeError
+    def initialize(missing_licenses)
+      msg = "Missing licenses for the following:\n* " + missing_licenses.join("\n* ")
+      super(msg)
+    end
+  end
+
+end

data/lib/license_acceptance/arg_acceptance.rb

@@ -0,0 +1,33 @@
+module LicenseAcceptance
+  class ArgAcceptance
+
+    def check(argv)
+      if argv.include?("--chef-license=accept")
+        return true
+      end
+      i = argv.index("--chef-license")
+      unless i.nil?
+        val = argv[i+1]
+        if val != nil && val.downcase == "accept"
+          return true
+        end
+      end
+      return false
+    end
+
+    def check_no_persist(argv)
+      if argv.include?("--chef-license=accept-no-persist")
+        return true
+      end
+      i = argv.index("--chef-license")
+      unless i.nil?
+        val = argv[i+1]
+        if val != nil && val.downcase == "accept-no-persist"
+          return true
+        end
+      end
+      return false
+    end
+
+  end
+end

data/lib/license_acceptance/cli_flags/mixlib_cli.rb

@@ -0,0 +1,22 @@
+begin
+  require 'mixlib/cli'
+rescue => exception
+  raise "Must have mixlib-cli gem installed to use this mixin"
+end
+
+module LicenseAcceptance
+  module CLIFlags
+
+    module MixlibCLI
+
+      def self.included(klass)
+        klass.option :chef_license,
+          long: "--chef-license ACCEPTANCE",
+          description: "Accept the license for this product and any contained products ('accept' or 'accept-no-persist')",
+          required: false
+      end
+
+    end
+
+  end
+end

data/lib/license_acceptance/cli_flags/thor.rb

@@ -0,0 +1,21 @@
+begin
+  require 'thor'
+rescue => exception
+  raise "Must have thor gem installed to use this mixin"
+end
+
+module LicenseAcceptance
+  module CLIFlags
+
+    module Thor
+
+      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'
+      end
+
+    end
+
+  end
+end

data/lib/license_acceptance/config.rb

@@ -0,0 +1,65 @@
+require 'logger'
+require 'tty-platform'
+
+module LicenseAcceptance
+  class Config
+    attr_accessor :output, :logger, :license_locations, :persist_location, :persist
+
+    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)
+      @license_locations = [ @license_locations ].flatten
+      @persist_location = opts.fetch(:persist_location, default_persist_location)
+      @persist = opts.fetch(:persist, true)
+    end
+
+    private
+
+    def platform
+      @platform ||= TTY::Platform.new
+    end
+
+    def is_root?
+      Process.uid == 0
+    end
+
+    def default_license_locations
+      if platform.windows?
+        l = [ File.join(ENV["HOMEDRIVE"], "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
+          possible_dirs = []
+          possible_dirs << ENV["HOME"] if ENV["HOME"]
+          possible_dirs << ENV["HOMEDRIVE"] + ENV["HOMEPATH"] if ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+          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/")
+              l << full_possible_dir
+              break
+            end
+          end
+        end
+      else
+        l = [ "/etc/chef/accepted_licenses/" ]
+        l << File.join(ENV['HOME'], ".chef/accepted_licenses/") unless is_root?
+      end
+      l
+    end
+
+    def default_persist_location
+      license_locations[-1]
+    end
+
+  end
+
+  class NoValidEnvironmentVar < StandardError
+    def initialize
+      super("no valid environment variables set on Windows")
+    end
+  end
+end

data/lib/license_acceptance/env_acceptance.rb

@@ -0,0 +1,19 @@
+module LicenseAcceptance
+  class EnvAcceptance
+
+    def check(env)
+      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == 'accept'
+        return true
+      end
+      return false
+    end
+
+    def check_no_persist(env)
+      if env['CHEF_LICENSE'] && env['CHEF_LICENSE'].downcase == 'accept-no-persist'
+        return true
+      end
+      return false
+    end
+
+  end
+end

data/lib/license_acceptance/file_acceptance.rb

@@ -0,0 +1,97 @@
+require 'date'
+require 'yaml'
+require 'fileutils'
+require 'etc'
+require "license_acceptance/logger"
+
+module LicenseAcceptance
+  class FileAcceptance
+    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 check(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