chef-licensing 0.4.43

data/lib/chef-licensing/license_key_fetcher/file.rb

@@ -0,0 +1,275 @@
+require "chef-config/windows"
+require "chef-config/path_helper"
+require "yaml"
+require "date"
+require "fileutils" unless defined?(FileUtils)
+require_relative "../license_key_fetcher"
+require_relative "../config"
+
+module ChefLicensing
+  class LicenseKeyFetcher
+
+    # Represents a fethced license ID recorded on disk
+    class File
+      LICENSE_KEY_FILE = "licenses.yaml".freeze
+      LICENSE_FILE_FORMAT_VERSION = "4.0.0".freeze
+
+      # License types list
+      LICENSE_TYPES = {
+        free: :free,
+        trial: :trial,
+        commercial: :commercial,
+      }.freeze
+
+      attr_reader :logger, :contents, :location
+      attr_accessor :local_dir # Optional local path to use to seek
+
+      def initialize(opts)
+        @opts = opts
+        @logger = ChefLicensing::Config.logger
+        @contents_ivar = nil
+        @location = nil
+
+        @opts[:dir] ||= LicenseKeyFetcher::File.default_file_location
+        @local_dir = @opts[:dir]
+      end
+
+      def fetch
+        read_license_key_file
+        contents&.key?(:licenses) ? fetch_license_keys(contents[:licenses]) : []
+      end
+
+      def fetch_license_keys(licenses)
+        licenses.collect { |x| x[:license_key] }
+      end
+
+      def fetch_license_types
+        read_license_key_file
+
+        if contents.nil? || contents[:licenses].nil?
+          []
+        else
+          contents[:licenses].collect { |x| x[:license_type] }
+        end
+      end
+
+      def user_has_active_trial_license?
+        @active_trial_status = false
+        read_license_key_file
+
+        if contents&.key?(:licenses)
+          @active_trial_status = contents[:licenses].any? { |license| license[:license_type] == :trial && ChefLicensing.client(license_keys: [license[:license_key]]).active? }
+        end
+        @active_trial_status
+      end
+
+      def fetch_allowed_license_types_for_addition
+        license_types = %i{free trial commercial}
+        existing_license_types = fetch_license_types
+
+        license_types -= [:trial] if existing_license_types.include? :trial
+        license_types -= [:free] if existing_license_types.include?(:free) || user_has_active_trial_license?
+        license_types.uniq
+      end
+
+      def fetch_license_keys_based_on_type(license_type)
+        read_license_key_file
+        if contents.nil?
+          []
+        else
+          contents[:licenses].collect do |x|
+            x[:license_key] if x[:license_type] == license_type
+          end.compact
+        end
+      end
+
+      # Writes a license_id file to disk in the location specified,
+      # with the content given.
+      # @return Array of Errors
+      def persist(license_key, license_type = nil)
+        raise LicenseKeyNotPersistedError.new("License type #{license_type} is not a valid license type.") unless LICENSE_TYPES[license_type.to_sym]
+
+        license_data = {
+          license_key: license_key,
+          license_type: LICENSE_TYPES[license_type.to_sym],
+          update_time: DateTime.now.to_s,
+        }
+
+        dir = @opts[:dir]
+        license_key_file_path = "#{dir}/#{LICENSE_KEY_FILE}"
+        create_license_directory_if_not_exist(dir, license_key_file_path)
+
+        @contents = load_license_file(license_key_file_path)
+
+        load_license_data_to_contents(license_data)
+        write_license_file(license_key_file_path)
+        []
+      end
+
+      # Returns true if a license_key file exists.
+      def persisted?
+        !!seek
+      end
+
+      def fetch_or_persist_url(license_server_url_from_config, license_server_url_from_system = nil)
+        dir = @opts[:dir]
+        license_key_file_path = "#{dir}/#{LICENSE_KEY_FILE}"
+        create_license_directory_if_not_exist(dir, license_key_file_path)
+
+        @contents = load_license_file(license_key_file_path)
+
+        if @contents.nil?
+          @contents = {
+            file_format_version: LICENSE_FILE_FORMAT_VERSION,
+            license_server_url: license_server_url_from_system || license_server_url_from_config,
+          }
+        else
+          if license_server_url_from_system && license_server_url_from_system != @contents[:license_server_url]
+            @contents[:license_server_url] = license_server_url_from_system
+          end
+        end
+
+        # Ensure the license server URL is returned to the caller in all cases
+        # (even if it's not persisted to the licenses.yaml file on the disk)
+        begin
+          write_license_file(license_key_file_path)
+        rescue StandardError => e
+          handle_error(e)
+        ensure
+          @license_server_url = @contents[:license_server_url]
+        end
+        logger.debug "License server URL: #{@license_server_url}"
+        @license_server_url
+      end
+
+      def self.default_file_location
+        ChefConfig::PathHelper.home(".chef")
+      end
+
+      def self.fetch_license_keys_based_on_type(license_type, opts = {})
+        new(opts).fetch_license_keys_based_on_type(license_type)
+      end
+
+      def self.user_has_active_trial_license?(opts = {})
+        new(opts).user_has_active_trial_license?
+      end
+
+      def self.fetch_or_persist_url(license_server_url_from_config, license_server_url_from_system = nil, opts = {})
+        new(opts).fetch_or_persist_url(license_server_url_from_config, license_server_url_from_system)
+      end
+
+      private
+
+      attr_accessor :license_server_url
+
+      # Look for an *existing* license_id file in several locations.
+      def seek
+        return location if location
+
+        on_windows = ChefConfig.windows?
+        candidates = []
+
+        # Include the user home directory ~/.chef
+        candidates << "#{self.class.default_file_location}/#{LICENSE_KEY_FILE}"
+        candidates << "/etc/chef/#{LICENSE_KEY_FILE}" unless on_windows
+
+        # Include software installation dirs for bespoke downloads.
+        # TODO: unlikely these would be writable if decision changes.
+        [
+          # TODO - get a complete list
+          "chef-workstation",
+          "inspec",
+        ].each do |inst_dir|
+          if on_windows
+            candidates << "C:/opscode/#{inst_dir}/#{LICENSE_KEY_FILE}"
+          else
+            candidates << "/opt/#{inst_dir}/#{LICENSE_KEY_FILE}"
+          end
+        end
+
+        # Include local directory if provided. Not usual, but useful for testing.
+        candidates << "#{local_dir}/#{LICENSE_KEY_FILE}" if local_dir
+
+        # Only picks up the first detected license file out of list of candidates
+        @location = candidates.detect { |c| ::File.exist?(c) }
+      end
+
+      def working_directory
+        (ChefConfig.windows? ? ENV["CD"] : ENV["PWD"]) || Dir.pwd
+      end
+
+      def read_license_key_file
+        return contents if contents
+
+        logger.debug "Reading license file from #{seek}"
+        path = seek
+        return nil unless path
+
+        # only checking for major version for file format for breaking changes
+        @contents ||= YAML.load(::File.read(path))
+        if major_version(@contents[:file_format_version]) == major_version(LICENSE_FILE_FORMAT_VERSION)
+          @contents
+        else
+          logger.debug "License File version #{@contents[:file_format_version]} not supported."
+          raise LicenseKeyNotFetchedError.new("License File version #{@contents[:file_format_version]} not supported.")
+        end
+      end
+
+      def major_version(version)
+        Gem::Version.new(version).segments[0]
+      end
+
+      def create_license_directory_if_not_exist(dir, license_key_file_path)
+        return if ::File.exist?(license_key_file_path)
+
+        logger.debug "Creating directory for license_key file at #{dir}"
+        msg = "Could not create directory for license_key file #{dir}"
+        FileUtils.mkdir_p(dir)
+      rescue StandardError => e
+        handle_error(e, msg)
+      end
+
+      def load_license_file(license_key_file_path)
+        return unless ::File.exist?(license_key_file_path)
+
+        logger.debug "Reading license_key file at #{license_key_file_path}"
+        msg = "Could not read license key file #{license_key_file_path}"
+        YAML.load_file(license_key_file_path)
+      rescue StandardError => e
+        handle_error(e, msg)
+      end
+
+      def load_license_data_to_contents(license_data)
+        return unless license_data
+
+        logger.debug "Loading license data to contents"
+        if @contents.nil? || @contents.empty? # this case is likely to happen only during testing
+          @contents = {
+            file_format_version: LICENSE_FILE_FORMAT_VERSION,
+            license_server_url: @license_server_url,
+            licenses: [license_data],
+          }
+        elsif @contents[:licenses].nil?
+          @contents[:licenses] = [license_data]
+        elsif fetch_license_keys(@contents[:licenses])&.include?(license_data[:license_key])
+          nil
+        else
+          @contents[:licenses] << license_data
+        end
+      end
+
+      def write_license_file(license_key_file_path)
+        logger.debug "Writing license_key file at #{license_key_file_path}"
+        msg = "Could not write telemetry license_key file #{license_key_file_path}"
+        ::File.write(license_key_file_path, YAML.dump(@contents))
+      rescue StandardError => e
+        handle_error(e, msg)
+      end
+
+      def handle_error(e, message = nil)
+        logger.debug "#{e.backtrace.join("\n\t")}"
+        e
+      end
+    end
+  end
+end

data/lib/chef-licensing/license_key_fetcher/prompt.rb

@@ -0,0 +1,43 @@
+require_relative "../tui_engine"
+
+module ChefLicensing
+  class LicenseKeyFetcher
+    class Prompt
+      attr_accessor :config, :tui_engine, :license_type
+
+      def initialize(config = {})
+        @config = config
+        initialize_tui_engine
+      end
+
+      def fetch
+        # Here info is a hash of { interaction_id: response }
+        info = tui_engine.run_interaction(config[:start_interaction])
+
+        # The interaction_id ask_for_license_id holds the license key
+        # TODO: Do we move this to tui_engine?
+        if info[:fetch_license_id].nil?
+          []
+        else
+          self.license_type = info[:license_type]
+          [info[:fetch_license_id]]
+        end
+      end
+
+      def append_info_to_tui_engine(extra_info_hash)
+        tui_engine.append_info_to_input(extra_info_hash)
+      end
+
+      private
+
+      def initialize_tui_engine
+        # use the default interaction file if interaction_file is nil
+        if config[:interaction_file].nil?
+          interaction_file_path = ::File.join(::File.dirname(__FILE__), "chef_licensing_interactions.yaml")
+          @config.store(:interaction_file, interaction_file_path)
+        end
+        @tui_engine = ChefLicensing::TUIEngine.new(@config)
+      end
+    end
+  end
+end

data/lib/chef-licensing/license_key_fetcher.rb

@@ -0,0 +1,314 @@
+require "chef-config/path_helper"
+require "chef-config/windows"
+
+require_relative "config"
+require_relative "context"
+require_relative "config_fetcher/arg_fetcher"
+require_relative "config_fetcher/env_fetcher"
+require_relative "license_key_fetcher/base"
+require_relative "license_key_fetcher/file"
+require_relative "license_key_fetcher/prompt"
+require_relative "../chef-licensing"
+require "tty-spinner"
+require_relative "exceptions/invalid_license"
+require_relative "exceptions/error"
+require_relative "exceptions/client_error"
+
+# LicenseKeyFetcher allows us to inspect obtain the license Key from the user in a variety of ways.
+module ChefLicensing
+  class LicenseKeyFetcher
+    class LicenseKeyNotFetchedError < RuntimeError
+    end
+
+    class LicenseKeyNotPersistedError < RuntimeError
+    end
+
+    class LicenseKeyAddNotAllowed < Error
+    end
+
+    attr_reader :config, :license_keys, :arg_fetcher, :env_fetcher, :file_fetcher, :prompt_fetcher, :logger
+    attr_accessor :client_api_call_error
+
+    def initialize(opts = {})
+      @config = opts
+      @logger = ChefLicensing::Config.logger
+      @config[:output] = ChefLicensing::Config.output
+      config[:logger] = logger
+      config[:dir] = opts[:dir]
+
+      # While using on-prem licensing service, @license_keys are fetched from API
+      logger.debug "License Key fetcher - fetching license keys depending upon the context (either API or file)"
+      # While using global licensing service, @license_keys are fetched from file
+      @license_keys = ChefLicensing::Context.license_keys(opts) || []
+
+      argv = opts[:argv] || ARGV
+      env = opts[:env] || ENV
+
+      # The various things that have a say in fetching the license Key.
+      @arg_fetcher = ChefLicensing::ArgFetcher.new(argv)
+      @env_fetcher = ChefLicensing::EnvFetcher.new(env)
+      @file_fetcher = LicenseKeyFetcher::File.new(config)
+      @prompt_fetcher = LicenseKeyFetcher::Prompt.new(config)
+      @license = nil
+    end
+
+    #
+    # Methods for obtaining consent from the user.
+    #
+    def fetch_and_persist
+      if ChefLicensing::Context.local_licensing_service?
+        perform_on_prem_operations
+      else
+        perform_global_operations
+      end
+    end
+
+    def perform_on_prem_operations
+      # While using on-prem licensing service no option to add/generate license is enabled
+
+      new_keys = fetch_license_key_from_arg
+      raise LicenseKeyAddNotAllowed.new("'--chef-license-key <value>' option is not supported with airgapped environment. You cannot add license from airgapped environment.") unless new_keys.empty?
+
+      unless @license_keys.empty?
+        # Licenses expiration check
+        if licenses_active?
+          return @license_keys
+        else
+          # Prompts if the keys are expired or expiring
+          if config[:output].isatty
+            append_extra_info_to_tui_engine # will add extra dynamic values in tui flows
+            logger.debug "License Key fetcher - detected TTY, prompting..."
+            prompt_fetcher.fetch
+          end
+        end
+      end
+
+      # Scenario: When a user is prompted for license expiry and license is not yet renewed
+      if %i{prompt_license_about_to_expire prompt_license_expired_local_mode}.include?(config[:start_interaction])
+        # Not blocking any license type in case of expiry
+        return @license_keys
+      end
+
+      # Otherwise nothing was able to fetch a license. Throw an exception.
+      logger.debug "License Key fetcher - no license Key able to be fetched."
+      raise LicenseKeyNotFetchedError.new("Unable to obtain a License Key.")
+    end
+
+    def perform_global_operations
+      logger.debug "License Key fetcher examining CLI arg checks"
+      new_keys = fetch_license_key_from_arg
+      license_type = validate_and_fetch_license_type(new_keys)
+      if license_type && !unrestricted_license_added?(new_keys, license_type)
+        # break the flow after the prompt if there is a restriction in adding license
+        # and return the license keys persisted in the file or @license_keys if any
+        return license_keys
+      end
+
+      logger.debug "License Key fetcher examining ENV checks"
+      new_keys = fetch_license_key_from_env
+      license_type = validate_and_fetch_license_type(new_keys)
+      if license_type && !unrestricted_license_added?(new_keys, license_type)
+        # break the flow after the prompt if there is a restriction in adding license
+        # and return the license keys persisted in the file or @license_keys if any
+        return license_keys
+      end
+
+      # Return keys if license keys are active and not expired or expiring
+      # Return keys if there is any error in /client API call, and do not block the flow.
+      # Client API possible errors will be handled in software entitlement check call (made after this)
+      return @license_keys if (!@license_keys.empty? && licenses_active?) || client_api_call_error
+
+      # Lowest priority is to interactively prompt if we have a TTY
+      if config[:output].isatty
+        append_extra_info_to_tui_engine # will add extra dynamic values in tui flows
+        logger.debug "License Key fetcher - detected TTY, prompting..."
+        new_keys = prompt_fetcher.fetch
+
+        unless new_keys.empty?
+          # If license type is not selected using TUI, assign it using API call to fetch type.
+          prompt_fetcher.license_type ||= get_license_type(new_keys.first)
+          persist_and_concat(new_keys, prompt_fetcher.license_type)
+          return license_keys
+        end
+      end
+
+      # Scenario: When a user is prompted for license expiry and license is not yet renewed
+      if new_keys.empty? && %i{prompt_license_about_to_expire prompt_license_expired}.include?(config[:start_interaction])
+        # Not blocking any license type in case of expiry
+        return @license_keys
+      end
+
+      # Otherwise nothing was able to fetch a license. Throw an exception.
+      logger.debug "License Key fetcher - no license Key able to be fetched."
+      raise LicenseKeyNotFetchedError.new("Unable to obtain a License Key.")
+    end
+
+    def add_license
+      logger.debug "License Key fetcher - add license flow, starting..."
+      if ChefLicensing::Context.local_licensing_service?
+        raise LicenseKeyAddNotAllowed.new("'inspec license add' command is not supported with airgapped environment. You cannot generate license from airgapped environment.")
+      else
+        config = {}
+        config[:start_interaction] = :add_license_all
+        prompt_fetcher.config = config
+        append_extra_info_to_tui_engine
+        new_keys = prompt_fetcher.fetch
+        unless new_keys.empty?
+          prompt_fetcher.license_type ||= get_license_type(new_keys.first)
+          persist_and_concat(new_keys, prompt_fetcher.license_type)
+          license_keys
+        end
+      end
+    end
+
+    # Note: Fetching from arg and env as well, to be able to fetch license when disk is non-writable
+    def fetch
+      # While using on-prem licensing service, @license_keys have been fetched from API
+      # While using global licensing service, @license_keys have been fetched from file
+      (fetch_license_key_from_arg << fetch_license_key_from_env << @license_keys).flatten.uniq
+    end
+
+    def self.fetch_and_persist(opts = {})
+      new(opts).fetch_and_persist
+    end
+
+    def self.fetch(opts = {})
+      new(opts).fetch
+    end
+
+    def self.add_license(opts = {})
+      new(opts).add_license
+    end
+
+    private
+
+    attr_accessor :license
+
+    def append_extra_info_to_tui_engine(info = {})
+      extra_info = {}
+
+      # default values
+      extra_info[:chef_product_name] = ChefLicensing::Config.chef_product_name&.capitalize
+      if license
+        extra_info[:license_type] = license.license_type.capitalize
+        extra_info[:number_of_days_in_expiration] = license.number_of_days_in_expiration
+        extra_info[:license_expiration_date] = Date.parse(license.expiration_date).strftime("%a, %d %b %Y")
+      end
+
+      unless info.empty? # ability to add info hash through arguments
+        info.each do |key, value|
+          extra_info[key] = value
+        end
+      end
+      prompt_fetcher.append_info_to_tui_engine(extra_info) unless extra_info.empty?
+    end
+
+    def licenses_active?
+      logger.debug "License Key fetcher - checking if licenses are active"
+      spinner = TTY::Spinner.new(":spinner [Running] License validation in progress...", format: :dots, clear: true, output: config[:output])
+      spinner.auto_spin # Start the spinner
+      # This call returns a license based on client logic
+      # This API call is only made when multiple license keys are present or if client call was never done
+      self.license = ChefLicensing.client(license_keys: @license_keys) if !license || @license_keys.count > 1
+      # Intentional lag of 2 seconds when license is expiring or expired
+      sleep 2 if license.expiring_or_expired?
+      spinner.success # Stop the spinner
+      if license.expired? || license.have_grace?
+        if ChefLicensing::Context.local_licensing_service?
+          config[:start_interaction] = :prompt_license_expired_local_mode
+        else
+          config[:start_interaction] = :prompt_license_expired
+        end
+        prompt_fetcher.config = config
+        false
+      elsif license.about_to_expire?
+        config[:start_interaction] = :prompt_license_about_to_expire
+        prompt_fetcher.config = config
+        false
+      else
+        true
+      end
+    rescue ChefLicensing::ClientError => e
+      spinner.success
+      logger.debug "Error in License Expiration Check using Client API #{e.message}"
+      self.client_api_call_error = true
+      false
+    end
+
+    def validate_and_fetch_license_type(new_keys)
+      unless new_keys.empty?
+        is_valid = validate_license_key(new_keys.first)
+        return get_license_type(new_keys.first) if is_valid
+      end
+    end
+
+    def persist_and_concat(new_keys, license_type)
+      file_fetcher.persist(new_keys.first, license_type)
+      @license_keys.concat(new_keys)
+    end
+
+    def fetch_license_key_from_arg
+      new_key = @arg_fetcher.fetch_value("--chef-license-key")
+      validate_license_key_format(new_key)
+    end
+
+    def fetch_license_key_from_env
+      new_key = @env_fetcher.fetch_value("CHEF_LICENSE_KEY")
+      validate_license_key_format(new_key)
+    end
+
+    def validate_license_key_format(license_key)
+      return [] if license_key.nil?
+
+      license_key = ChefLicensing::LicenseKeyFetcher::Base.verify_and_extract_license(license_key)
+      [license_key]
+    end
+
+    def validate_license_key(license_key)
+      ChefLicensing::LicenseKeyValidator.validate!(license_key)
+    end
+
+    def get_license_type(license_key)
+      self.license = ChefLicensing.client(license_keys: [license_key])
+      license.license_type.downcase.to_sym
+    end
+
+    def license_restricted?(license_type)
+      allowed_license_types = file_fetcher.fetch_allowed_license_types_for_addition
+      !(allowed_license_types.include? license_type)
+    end
+
+    def prompt_license_addition_restricted(license_type, existing_license_keys_in_file)
+      logger.debug "License Key fetcher - prompting license addition restriction"
+      # For trial license
+      # TODO for free license
+      config[:start_interaction] = :prompt_license_addition_restriction
+      prompt_fetcher.config = config
+      # Existing license keys are needed to show details of existing license of license type which is restricted.
+      append_extra_info_to_tui_engine({ license_id: existing_license_keys_in_file.last, license_type: license_type })
+      prompt_fetcher.fetch
+    end
+
+    def unrestricted_license_added?(new_keys, license_type)
+      if license_restricted?(license_type)
+        # Existing license keys of same license type are fetched to compare if old license key or a new one is added.
+        # However, if user is trying to add free license, and user has active trial license, we fetch the trial license key
+        if license_type == :free && file_fetcher.user_has_active_trial_license?
+          existing_license_keys_in_file = file_fetcher.fetch_license_keys_based_on_type(:trial)
+        else
+          existing_license_keys_in_file = file_fetcher.fetch_license_keys_based_on_type(license_type)
+        end
+        # Only prompt when a new trial license is added
+        unless existing_license_keys_in_file.last == new_keys.first
+          # prompt the message that this addition of license is restricted.
+          prompt_license_addition_restricted(license_type, existing_license_keys_in_file)
+          return false
+        end
+        true # license type is restricted but not the key since it is the same key hence returning true
+      else
+        persist_and_concat(new_keys, license_type)
+        true
+      end
+    end
+  end
+end

data/lib/chef-licensing/license_key_generator.rb

@@ -0,0 +1,47 @@
+require_relative "restful_client/v1"
+require_relative "exceptions/license_generation_failed"
+
+module ChefLicensing
+  class LicenseKeyGenerator
+    attr_reader :payload
+
+    class << self
+      # @param [Hash] KWARGS keys accepted are [first_name, last_name, email_id, product, company, phone]
+      def generate_trial_license!(kwargs)
+        new(kwargs).generate_trial_license!
+      end
+
+      def generate_free_license!(kwargs)
+        new(kwargs).generate_free_license!
+      end
+    end
+
+    def initialize(kwargs, restful_client: ChefLicensing::RestfulClient::V1)
+      # TODO: validate kwargs
+      @payload = build_payload_from(kwargs)
+      @restful_client = restful_client.new
+    end
+
+    def generate_trial_license!
+      response = @restful_client.generate_trial_license(payload)
+      # need some logic around delivery
+      # how the delivery is decided?
+      response.licenseId
+    rescue RestfulClientError => e
+      raise ChefLicensing::LicenseGenerationFailed, e.message
+    end
+
+    def generate_free_license!
+      response = @restful_client.generate_free_license(payload)
+      response.licenseId
+    rescue RestfulClientError => e
+      raise ChefLicensing::LicenseGenerationFailed, e.message
+    end
+
+    private
+
+    def build_payload_from(kwargs)
+      kwargs.slice(:first_name, :last_name, :email_id, :product, :company, :phone)
+    end
+  end
+end