chef-licensing 0.4.43

data/lib/chef-licensing/license_key_validator.rb

@@ -0,0 +1,24 @@
+require_relative "restful_client/v1"
+require_relative "exceptions/invalid_license"
+
+module ChefLicensing
+  class LicenseKeyValidator
+    attr_reader :license
+
+    class << self
+      def validate!(license)
+        new(license).validate!
+      end
+    end
+
+    def initialize(license, restful_client: ChefLicensing::RestfulClient::V1)
+      @license = license || raise(ArgumentError, "Missing Params: `license`")
+      @restful_client = restful_client.new
+    end
+
+    def validate!
+      response = @restful_client.validate(license)
+      response.data || raise(ChefLicensing::InvalidLicense, response.message)
+    end
+  end
+end

data/lib/chef-licensing/licensing_service/local.rb

@@ -0,0 +1,29 @@
+require_relative "../config"
+require_relative "../api/list_licenses"
+require_relative "../exceptions/list_licenses_error"
+
+module ChefLicensing
+  class LicensingService
+    class Local
+      attr_reader :logger
+
+      class << self
+        def detected?
+          new.detected?
+        end
+      end
+
+      def detected?
+        return ChefLicensing::Config.is_local_license_service if ChefLicensing::Config.is_local_license_service
+
+        ChefLicensing::Api::ListLicenses.info
+        true
+      rescue ChefLicensing::ListLicensesError => e
+        # If API call returns 404, it is a global licensing service
+        return false if e.status_code == 404
+
+        raise(ChefLicensing::ListLicensesError.new("Error occured while fetching licenses #{e.message}", e.status_code))
+      end
+    end
+  end
+end

data/lib/chef-licensing/list_license_keys.rb

@@ -0,0 +1,142 @@
+require_relative "license_key_fetcher"
+require_relative "api/describe"
+require_relative "exceptions/describe_error"
+require "pastel" unless defined?(Pastel)
+require_relative "config"
+
+module ChefLicensing
+  class ListLicenseKeys
+    def self.display(opts = {})
+      new(opts).display
+    end
+
+    def self.display_overview(opts = {})
+      new(opts).display_overview
+    end
+
+    def initialize(opts = {})
+      @logger = ChefLicensing::Config.logger
+      @output = ChefLicensing::Config.output
+      @pastel = Pastel.new
+      @license_keys = fetch_license_keys(opts)
+      @licenses_metadata = fetch_licenses_metadata
+    end
+
+    def display
+      output.puts "+------------ License Information ------------+"
+      output.puts "Total Licenses found: #{licenses_metadata.length}\n\n"
+
+      licenses_metadata.each do |license|
+        puts_bold "License Key     : #{license.id}"
+        output.puts <<~LICENSE
+          Type            : #{license.license_type}
+          Status          : #{license.status}
+          Expiration Date : #{license.expiration_date}
+
+        LICENSE
+
+        iterate_attributes(license.software_entitlements, "Software Entitlements")
+        iterate_attributes(license.asset_entitlements, "Asset Entitlements")
+        iterate_attributes(license.feature_entitlements, "Feature Entitlements")
+
+        puts_bold "License Limits"
+        license.limits.each do |limit|
+          usage_limit = limit.usage_limit == -1 ? "Unlimited" : limit.usage_limit
+          output.puts <<~LIMIT
+            Usage Status  : #{limit.usage_status}
+            Usage Limit   : #{usage_limit}
+            Usage Measure : #{limit.usage_measure}
+            Used          : #{limit.used}
+            Software      : #{limit.software}
+          LIMIT
+        end
+        output.puts "+----------------------------------------------+"
+      end
+    end
+
+    def display_overview
+      output.puts "------------------------------------------------------------"
+      licenses_metadata.each do |license|
+        # Sets the validity text for a free license as "Unlimited" and displays the number of days for others.
+        validity = if license.license_type == "free"
+                     "Unlimited"
+                   else
+                     # find the number of days left for the license to expire
+                     days = (Date.parse(license.expiration_date) - Date.today).to_i
+                     "#{days > 0 ? days : 0} #{"Day".pluralize(days)}"
+                   end
+        num_of_units = license.limits&.first&.usage_limit || 0
+        num_of_units = num_of_units == -1 ? "Unlimited" : num_of_units
+        unit_measure = license.limits&.first&.usage_measure || "unit"
+        output.puts <<~LICENSE
+            #{pastel.bold("License Details")}
+              Asset Name       : #{license.limits.first.software}
+              License ID       : #{license.id}
+              Type             : #{license.license_type.capitalize}
+              Status           : #{license.status.capitalize}
+              Validity         : #{validity}
+              No. Of Units     : #{num_of_units} #{unit_measure.capitalize.pluralize(num_of_units)}
+            ------------------------------------------------------------
+        LICENSE
+      end
+    end
+
+    private
+
+    attr_reader :pastel, :output, :logger, :license_keys, :licenses_metadata
+
+    def display_info(component)
+      output.puts <<~INFO
+        ID       : #{component.id}
+        Name     : #{component.name}
+        Status   : #{component.status}
+        Entitled : #{component.entitled}
+      INFO
+      output.puts "\n"
+    end
+
+    def iterate_attributes(component, header)
+      puts_bold header
+      puts "No #{header.downcase} found.\n\n" if component.empty?
+      component.each do |attribute|
+        display_info(attribute)
+      end
+    end
+
+    def puts_bold(title)
+      output.puts pastel.bold(title)
+    end
+
+    def fetch_license_keys(opts = {})
+      license_keys = opts[:license_keys] || ChefLicensing::LicenseKeyFetcher.fetch({ dir: opts[:dir] })
+
+      if license_keys.empty?
+        logger.debug "No license keys found on disk."
+        output.puts "No license keys found on disk."
+        exit
+      end
+      logger.debug "License keys fetched from disk: #{license_keys}"
+
+      license_keys
+    rescue ChefLicensing::LicenseKeyFetcher::LicenseKeyNotFetchedError => e
+      logger.debug "Error occured while fetching license keys from disk: #{e.message}"
+      output.puts "Error occured while fetching license keys from disk: #{e.message}"
+      # TODO: Exit with a non-zero status code
+      exit
+    end
+
+    def fetch_licenses_metadata
+      licenses_metadata = ChefLicensing::Api::Describe.list({
+        license_keys: license_keys,
+      })
+      logger.debug "License metadata fetched from server: #{licenses_metadata}"
+
+      licenses_metadata
+    rescue ChefLicensing::DescribeError => e
+      logger.debug "Error occured while fetching license information: #{e.message}"
+      output.puts "Error occured while fetching license information: #{e.message}"
+      # TODO: Exit with a non-zero status code
+      exit
+    end
+  end
+end

data/lib/chef-licensing/restful_client/base.rb

@@ -0,0 +1,139 @@
+require "faraday" unless defined?(Faraday)
+require "faraday/http_cache"
+require "active_support"
+require "tmpdir" unless defined?(Dir.mktmpdir)
+require_relative "../exceptions/restful_client_error"
+require_relative "../exceptions/restful_client_connection_error"
+require_relative "../exceptions/missing_api_credentials_error"
+require_relative "../config"
+require_relative "middleware/exceptions_handler"
+
+module ChefLicensing
+  module RestfulClient
+
+    # Base class to handle all License Server endpoints
+    class Base
+
+      END_POINTS = {
+        FEATURE_BY_NAME: "license-service/featurebyname",
+        FEATURE_BY_ID: "license-service/featurebyid",
+        ENTITLEMENT_BY_NAME: "license-service/entitlementbyname",
+        ENTITLEMENT_BY_ID: "license-service/entitlementbyid",
+      }.freeze
+
+      CURRENT_ENDPOINT_VERSION = 2
+
+      def initialize
+        raise MissingAPICredentialsError, "Missing credential in config: Set in block chef_license_server or use environment variable CHEF_LICENSE_SERVER or pass through argument --chef-license-server" if ChefLicensing::Config.license_server_url.nil?
+
+        @logger = ChefLicensing::Config.logger
+      end
+
+      def validate(license)
+        invoke_get_api(self.class::END_POINTS[:VALIDATE], { licenseId: license, version: CURRENT_ENDPOINT_VERSION })
+      end
+
+      def generate_trial_license(payload)
+        invoke_post_api(self.class::END_POINTS[:GENERATE_TRIAL_LICENSE], payload)
+      end
+
+      def generate_free_license(payload)
+        invoke_post_api(self.class::END_POINTS[:GENERATE_FREE_LICENSE], payload)
+      end
+
+      def feature_by_name(payload)
+        invoke_post_api(self.class::END_POINTS[:FEATURE_BY_NAME], payload)
+      end
+
+      def feature_by_id(payload)
+        invoke_post_api(self.class::END_POINTS[:FEATURE_BY_ID], payload)
+      end
+
+      def entitlement_by_name(payload)
+        invoke_post_api(self.class::END_POINTS[:ENTITLEMENT_BY_NAME], payload)
+      end
+
+      def entitlement_by_id(payload)
+        invoke_post_api(self.class::END_POINTS[:ENTITLEMENT_BY_ID], payload)
+      end
+
+      def client(params = {})
+        invoke_get_api(self.class::END_POINTS[:CLIENT], { licenseId: params[:license_keys], entitlementId: params[:entitlement_id] })
+      end
+
+      def describe(params = {})
+        invoke_get_api(self.class::END_POINTS[:DESCRIBE], { licenseId: params[:license_keys], entitlementId: params[:entitlement_id] })
+      end
+
+      def list_licenses(params = {})
+        invoke_get_api(self.class::END_POINTS[:LIST_LICENSES])
+      end
+
+      private
+
+      attr_reader :logger
+
+      # a common method to handle the get API calls
+      def invoke_get_api(endpoint, params = {})
+        handle_get_connection do |connection|
+          connection.get(endpoint, params).body
+        end
+      end
+
+      # a common method to handle the post API calls
+      def invoke_post_api(endpoint, payload, headers = {})
+        handle_post_connection do |connection|
+          response = connection.post(endpoint) do |request|
+            request.body = payload.to_json
+            request.headers = headers
+          end
+          raise RestfulClientError, format_error_from(response) unless response.success?
+
+          response.body
+        end
+      end
+
+      def handle_get_connection
+        # handle faraday errors
+        yield get_connection
+      rescue Faraday::ClientError => e
+        logger.debug "Restful Client Error #{e.message}"
+        raise RestfulClientError, e.message
+      end
+
+      def handle_post_connection
+        # handle faraday errors
+        yield post_connection
+      rescue Faraday::ClientError => e
+        logger.debug "Restful Client Error #{e.message}"
+        raise RestfulClientError, e.message
+      end
+
+      def get_connection
+        store = ::ActiveSupport::Cache.lookup_store(:file_store, Dir.tmpdir)
+        Faraday.new(url: ChefLicensing::Config.license_server_url) do |config|
+          config.request :json
+          config.response :json, parser_options: { object_class: OpenStruct }
+          config.use Faraday::HttpCache, shared_cache: false, logger: logger, store: store
+          config.use Middleware::ExceptionsHandler
+          config.adapter Faraday.default_adapter
+        end
+      end
+
+      def post_connection
+        Faraday.new(url: ChefLicensing::Config.license_server_url) do |config|
+          config.request :json
+          config.response :json, parser_options: { object_class: OpenStruct }
+          config.use Middleware::ExceptionsHandler
+        end
+      end
+
+      def format_error_from(response)
+        error_details = response.body&.data&.error
+        return response.reason_phrase unless error_details
+
+        error_details
+      end
+    end
+  end
+end

data/lib/chef-licensing/restful_client/middleware/exceptions_handler.rb

@@ -0,0 +1,16 @@
+require "faraday" unless defined?(Faraday)
+require "faraday/middleware"
+require_relative "../../../chef-licensing/exceptions/restful_client_connection_error"
+
+module Middleware
+  # Middleware that handles the exception handler for chef licensing
+  class ExceptionsHandler < Faraday::Middleware
+    def call(env)
+      @app.call(env)
+    rescue Faraday::ConnectionFailed => e
+      ChefLicensing::Config.logger.debug("Connection failed to #{ChefLicensing::Config.license_server_url} with error: #{e.message}")
+      error_message = "Unable to connect to the licensing server at #{ChefLicensing::Config.license_server_url}.\nPlease check if the server is reachable and try again. #{ChefLicensing::Config.chef_product_name} requires server communication to operate."
+      raise ChefLicensing::RestfulClientConnectionError, error_message
+    end
+  end
+end

data/lib/chef-licensing/restful_client/v1.rb

@@ -0,0 +1,17 @@
+require_relative "base"
+
+module ChefLicensing
+  module RestfulClient
+    # Client that handles all License Server V1 endpoints
+    class V1 < Base
+      END_POINTS = END_POINTS.merge({
+        VALIDATE: "v1/validate",
+        GENERATE_TRIAL_LICENSE: "v1/trial",
+        GENERATE_FREE_LICENSE: "v1/free",
+        CLIENT: "v1/client",
+        DESCRIBE: "v1/desc",
+        LIST_LICENSES: "v1/listLicenses",
+      }).freeze
+    end
+  end
+end

data/lib/chef-licensing/tui_engine/tui_actions.rb

@@ -0,0 +1,238 @@
+require_relative "../license_key_validator"
+require_relative "../license_key_generator"
+require_relative "../exceptions/invalid_license"
+require_relative "../exceptions/license_generation_failed"
+require_relative "../exceptions/license_generation_rejected"
+require_relative "../license_key_fetcher/base"
+require_relative "../config"
+require_relative "../context"
+require_relative "../list_license_keys"
+require "tty-spinner"
+
+module ChefLicensing
+  class TUIEngine
+    class TUIActions
+      attr_accessor :logger, :output, :license_id, :error_msg, :rejection_msg, :invalid_license_msg, :license_type, :license
+      def initialize(opts = {})
+        @opts = opts
+        @logger = ChefLicensing::Config.logger
+        @output = ChefLicensing::Config.output
+      end
+
+      def is_license_with_valid_pattern?(input)
+        license_id = input[:ask_for_license_id]
+        input[:ask_for_license_id] = ChefLicensing::LicenseKeyFetcher::Base.verify_and_extract_license(license_id)
+        true
+      rescue ChefLicensing::LicenseKeyFetcher::Base::InvalidLicenseKeyFormat => e
+        output.puts e.message
+        logger.debug e.message
+        false
+      end
+
+      def is_license_valid_on_server?(input)
+        license_id = input[:ask_for_license_id]
+        spinner = TTY::Spinner.new(":spinner [Running] License validation in progress...", format: :dots, clear: true, output: output)
+        spinner.auto_spin # Start the spinner
+        is_valid = ChefLicensing::LicenseKeyValidator.validate!(license_id)
+        spinner.success # Stop the spinner
+        self.license_id = license_id
+        is_valid
+      rescue ChefLicensing::InvalidLicense => e
+        spinner.error # Stop the spinner
+        self.invalid_license_msg = e.message || "Something went wrong while validating the license"
+        false
+      end
+
+      def is_license_allowed?(input)
+        client_api_call(license_id)
+        self.license_type = get_license_type
+        if license_restricted?(license_type)
+          # Existing license keys needs to be fetcher to show details of existing license of license type which is restricted.
+          # 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 && LicenseKeyFetcher::File.user_has_active_trial_license?(@opts)
+            existing_license_keys_in_file = LicenseKeyFetcher::File.fetch_license_keys_based_on_type(:trial, @opts)
+          else
+            existing_license_keys_in_file = LicenseKeyFetcher::File.fetch_license_keys_based_on_type(license_type, @opts)
+          end
+          self.license_id = existing_license_keys_in_file.last
+          false
+        else
+          true
+        end
+      end
+
+      def license_expiration_status?(input)
+        get_license(license_id)
+        if license.expired? || license.have_grace?
+          ChefLicensing::Context.local_licensing_service? ? "expired_in_local_mode" : "expired"
+        elsif license.about_to_expire?
+          input[:license_expiration_date] = Date.parse(license.expiration_date).strftime("%a, %d %b %Y")
+          input[:number_of_days_in_expiration] = license.number_of_days_in_expiration
+          "about_to_expire"
+        else
+          "active"
+        end
+      end
+
+      def is_user_name_valid?(input)
+        user_name = input[:gather_user_last_name_for_license_generation] || input[:gather_user_first_name_for_license_generation]
+        (user_name =~ /\A[a-zA-Z]{1,16}\Z/) == 0
+      end
+
+      def is_email_valid?(input)
+        (input[:gather_user_email_for_license_generation] =~ URI::MailTo::EMAIL_REGEXP) == 0
+      end
+
+      def is_company_name_valid?(input)
+        (input[:gather_user_company_for_license_generation] =~ /\A[a-zA-Z0-9][a-zA-Z0-9\W_]{2,15}\z/) == 0
+      end
+
+      def is_phone_no_valid?(input)
+        # No validation
+        # Optional field
+        true
+      end
+
+      def generate_trial_license(input)
+        generate_license(input, :trial)
+      end
+
+      def generate_free_license(input)
+        generate_license(input, :free)
+      end
+
+      def fetch_license_id(input)
+        license_id
+      end
+
+      def fetch_license_failure_error_msg(input)
+        error_msg
+      end
+
+      def fetch_license_failure_rejection_msg(input)
+        rejection_msg
+      end
+
+      def select_license_generation_based_on_type(inputs)
+        if inputs.key? :free_license_selection
+          inputs[:license_type] = :free
+          "free"
+        elsif inputs.key? :trial_license_selection
+          inputs[:license_type] = :trial
+          "trial"
+        else
+          inputs[:license_type] = :commercial
+          "commercial"
+        end
+      end
+
+      def license_generation_rejected?(inputs)
+        !!rejection_msg
+      end
+
+      def fetch_invalid_license_msg(input)
+        invalid_license_msg
+      end
+
+      def display_license_info(inputs)
+        ChefLicensing::ListLicenseKeys.display_overview({ license_keys: [license_id] })
+      end
+
+      def clear_license_type_selection(inputs)
+        inputs.delete(:free_license_selection)
+        inputs.delete(:trial_license_selection)
+        inputs.delete(:commercial_license_selection)
+      end
+
+      def are_user_details_present?(inputs)
+        inputs.key?(:gather_user_first_name_for_license_generation) &&
+          inputs.key?(:gather_user_last_name_for_license_generation) &&
+          inputs.key?(:gather_user_email_for_license_generation) &&
+          inputs.key?(:gather_user_company_for_license_generation) &&
+          inputs.key?(:gather_user_phone_no_for_license_generation)
+      end
+
+      def set_license_info(input)
+        self.license_id = input[:license_id]
+        self.license_type = input[:license_type]
+      end
+
+      def determine_restriction_type(input)
+        if license_type == :free && LicenseKeyFetcher::File.user_has_active_trial_license?(@opts)
+          "active_trial_restriction"
+        else
+          "#{license_type}_restriction"
+        end
+      end
+
+      def fetch_license_type_restricted(inputs)
+        if license_restricted?(:trial) && license_restricted?(:free)
+          "trial_and_free"
+        elsif license_restricted?(:trial)
+          "trial"
+        else
+          "free"
+        end
+      end
+
+      def filter_license_type_options(inputs)
+        if (license_restricted?(:trial) && license_restricted?(:free)) || LicenseKeyFetcher::File.user_has_active_trial_license?(@opts)
+          "ask_for_commercial_only"
+        elsif license_restricted?(:trial)
+          "ask_for_license_except_trial"
+        elsif license_restricted?(:free)
+          "ask_for_license_except_free"
+        else
+          "ask_for_all_license_type"
+        end
+      end
+
+      private
+
+      attr_accessor :opts
+
+      def generate_license(inputs, license_type)
+        spinner = TTY::Spinner.new(":spinner [Running] License generation in progress...", format: :dots, clear: true, output: output)
+        spinner.auto_spin # Start the spinner
+        self.license_id = ChefLicensing::LicenseKeyGenerator.send("generate_#{license_type}_license!",
+          first_name: inputs[:gather_user_first_name_for_license_generation],
+          last_name: inputs[:gather_user_last_name_for_license_generation],
+          email_id: inputs[:gather_user_email_for_license_generation],
+          product: ChefLicensing::Config.chef_product_name&.capitalize,
+          company: inputs[:gather_user_company_for_license_generation],
+          phone: inputs[:gather_user_phone_no_for_license_generation])
+        spinner.success # Stop the spinner
+        true
+      rescue ChefLicensing::LicenseGenerationFailed => e
+        spinner.error # Stop the spinner
+        self.error_msg = e.message
+        false
+      rescue ChefLicensing::LicenseGenerationRejected => e
+        spinner.error # Stop the spinner
+        self.rejection_msg = e.message
+        false
+      end
+
+      def get_license(license_key)
+        spinner = TTY::Spinner.new(":spinner [Running] License validation in progress...", format: :dots, clear: true, output: output)
+        spinner.auto_spin # Start the spinner
+        client_api_call(license_key)
+        spinner.success # Stop the spinner
+      end
+
+      def client_api_call(license_key)
+        self.license ||= ChefLicensing.client(license_keys: [license_key])
+      end
+
+      def get_license_type
+        license.license_type.downcase.to_sym
+      end
+
+      def license_restricted?(license_type)
+        file_fetcher = LicenseKeyFetcher::File.new(@opts)
+        allowed_license_types = file_fetcher.fetch_allowed_license_types_for_addition
+        !(allowed_license_types.include? license_type)
+      end
+    end
+  end
+end