chef-licensing 0.4.44 → 1.0.0

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

@@ -5,6 +5,10 @@ require "date"
 require "fileutils" unless defined?(FileUtils)
 require_relative "../license_key_fetcher"
 require_relative "../config"
+require_relative "../exceptions/license_file_corrupted"
+require_relative "license_file/v4"
+require_relative "license_file/v3"
+require_relative "../exceptions/invalid_file_format_version"
 
 module ChefLicensing
   class LicenseKeyFetcher
@@ -63,6 +67,15 @@ module ChefLicensing
         @active_trial_status
       end
 
+      def user_has_active_trial_or_free_license?
+        read_license_key_file
+        return false unless contents&.key?(:licenses)
+
+        all_license_keys = contents[:licenses].collect { |license| license[:license_key] }
+        license_obj = ChefLicensing.client(license_keys: all_license_keys)
+        (%w{trial free}.include? license_obj.license_type&.downcase) && license_obj.active?
+      end
+
       def fetch_allowed_license_types_for_addition
         license_types = %i{free trial commercial}
         existing_license_types = fetch_license_types
@@ -118,15 +131,15 @@ module ChefLicensing
 
         @contents = load_license_file(license_key_file_path)
 
+        # Two possible cases:
+        # 1. If contents is nil, load basic license data with the latest structure.
+        # 2. If contents is not nil, but the license server URL in contents is different from the system's,
+        #    update the license server URL in contents and licenses.yaml file.
         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
+          url = license_server_url_from_system || license_server_url_from_config
+          load_basic_license_data_to_contents(url, [])
+        elsif @contents && license_server_url_from_system && license_server_url_from_system != @contents[:license_server_url]
+          @contents[:license_server_url] = license_server_url_from_system
         end
 
         # Ensure the license server URL is returned to the caller in all cases
@@ -207,11 +220,27 @@ module ChefLicensing
 
         # only checking for major version for file format for breaking changes
         @contents ||= YAML.load(::File.read(path))
+
+        # raise error if the file_format_version key is missing
+        raise LicenseFileCorrupted.new("Unrecognized license file; :file_format_version missing.") unless @contents.key?(:file_format_version)
+
+        # Three possible cases after loading the license file contents:
+        # 1. If the file format version is the same as the current version (latest), verify the structure and return the contents.
+        # 2. If the file format version is different but supported, migrate the contents to the current version and return them.
+        # 3. If the file format version is different and not supported, raise an error.
         if major_version(@contents[:file_format_version]) == major_version(LICENSE_FILE_FORMAT_VERSION)
+          current_version_class_name = get_license_file_class(LICENSE_FILE_FORMAT_VERSION)
+          # we ignore any additional keys in the license file during verification
+          raise LicenseFileCorrupted.new("Invalid data found in the license file.") unless current_version_class_name.send(:verify_structure, @contents)
+
+          @contents
+        elsif license_file_class_exists?(@contents[:file_format_version])
+          @contents = migrate_license_file_content_to_current_version(@contents)
+          write_license_file(path) # update the license file contents to the latest 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.")
+          raise ChefLicensing::InvalidFileFormatVersion.new("Unable to read licenses. License File version #{@contents[:file_format_version]} not supported.")
         end
       end
 
@@ -244,11 +273,7 @@ module ChefLicensing
 
         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],
-          }
+          load_basic_license_data_to_contents(@license_server_url, [license_data])
         elsif @contents[:licenses].nil?
           @contents[:licenses] = [license_data]
         elsif fetch_license_keys(@contents[:licenses])&.include?(license_data[:license_key])
@@ -270,6 +295,38 @@ module ChefLicensing
         logger.debug "#{e.backtrace.join("\n\t")}"
         e
       end
+
+      # Returns the license file class for the given version.
+      def get_license_file_class(version)
+        Object.const_get("ChefLicensing::LicenseFile::V#{major_version(version)}")
+      end
+
+      # Returns true if the license file class for the given version exists.
+      def license_file_class_exists?(version)
+        Object.const_defined?("ChefLicensing::LicenseFile::V#{major_version(version)}")
+      end
+
+      # Loads the basic license data to contents in the current version's structure.
+      def load_basic_license_data_to_contents(url, license_data = [])
+        current_version_class_name = get_license_file_class(LICENSE_FILE_FORMAT_VERSION)
+        @contents = current_version_class_name.send(:load_primary_structure)
+        @contents[:file_format_version] = LICENSE_FILE_FORMAT_VERSION
+        @contents[:license_server_url] = url || ""
+        @contents[:licenses] = license_data
+      end
+
+      # Migrates the license file content to the current version and returns the migrated contents.
+      def migrate_license_file_content_to_current_version(contents)
+        logger.warn "License File version #{contents[:file_format_version]} is deprecated."
+        logger.warn "Automatically migrating license file to version #{LICENSE_FILE_FORMAT_VERSION}."
+        given_version_class_name = get_license_file_class(contents[:file_format_version])
+        # we ignore any additional keys in the license file during verification
+        raise LicenseFileCorrupted.new("Invalid data found in the license file.") unless given_version_class_name.send(:verify_structure, contents)
+
+        current_version_class_name = get_license_file_class(LICENSE_FILE_FORMAT_VERSION)
+        contents = current_version_class_name.send(:migrate_structure, contents, major_version(contents[:file_format_version]))
+        contents
+      end
     end
   end
 end

data/lib/chef-licensing/license_key_fetcher/license_file/base.rb

@@ -0,0 +1,63 @@
+module ChefLicensing
+  module LicenseFile
+    class Base
+      EXPECTED_STRUCTURE = {
+        file_format_version: "0.0.0",
+        licenses: [
+          {
+            license_key: String,
+            license_type: Symbol,
+            update_time: String,
+          },
+        ],
+      }.freeze
+
+      # @param [Hash] data: The data to verify
+      # @param [Hash] expected_structure: The structure to verify against
+      # @return [Boolean] true if the data matches the expected structure, false otherwise
+      # @note This method ignores extra keys in the data that are not in the expected structure
+      def self.verify_structure(data, expected_structure = self::EXPECTED_STRUCTURE)
+        return false unless data.is_a?(Hash)
+
+        expected_structure.each do |key, value|
+          return false unless data.key?(key)
+
+          if value.is_a?(Hash)
+            return false unless verify_structure(data[key], value)
+          elsif value.is_a?(Array)
+            return false unless data[key].is_a?(Array)
+
+            data[key].each do |item|
+              return false unless verify_structure(item, value[0])
+            end
+          elsif value.is_a?(Class)
+            return false unless data[key].is_a?(value)
+          else
+            return false unless data[key] == value
+          end
+        end
+
+        true
+      end
+
+      # @return [Hash] The primary structure of the license file, without nested structures
+      def self.load_primary_structure
+        expected_structure_dup = self::EXPECTED_STRUCTURE.dup
+        expected_structure_dup[:licenses] = []
+        expected_structure_dup
+      end
+
+      # @return [Hash] The complete structure of the license file, including nested structures
+      def self.load_structure
+        self::EXPECTED_STRUCTURE
+      end
+
+      # @param [Hash] contents: The contents of the license file
+      # @param [Integer] version: The version of the license file
+      # @return [Hash] The contents of the license file after migration
+      def self.migrate_structure(contents, version)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+  end
+end

data/lib/chef-licensing/license_key_fetcher/license_file/v3.rb

@@ -0,0 +1,12 @@
+require_relative "base"
+
+module ChefLicensing
+  module LicenseFile
+    class V3 < Base
+      LICENSE_FILE_FORMAT_VERSION = "3.0.0".freeze
+      EXPECTED_STRUCTURE = EXPECTED_STRUCTURE.merge({
+        file_format_version: V3::LICENSE_FILE_FORMAT_VERSION,
+      }).freeze
+    end
+  end
+end

data/lib/chef-licensing/license_key_fetcher/license_file/v4.rb

@@ -0,0 +1,27 @@
+require_relative "base"
+require_relative "../../config"
+
+module ChefLicensing
+  module LicenseFile
+    class V4 < Base
+      LICENSE_FILE_FORMAT_VERSION = "4.0.0".freeze
+
+      EXPECTED_STRUCTURE = EXPECTED_STRUCTURE.merge({
+        file_format_version: V4::LICENSE_FILE_FORMAT_VERSION,
+        license_server_url: String,
+      }).freeze
+
+      # @param [Hash] contents: The contents of the license file
+      # @param [Integer] version: The version of the license file
+      # @return [Hash] The contents of the license file after migration
+      def self.migrate_structure(contents, version)
+        # Backwards compatibility for version 3 license files
+        if version == 3
+          contents[:license_server_url] = ChefLicensing::Config.license_server_url || ""
+          contents[:file_format_version] = V4::LICENSE_FILE_FORMAT_VERSION
+        end
+        contents
+      end
+    end
+  end
+end

data/lib/chef-licensing/license_key_fetcher.rb

@@ -71,7 +71,9 @@ module ChefLicensing
 
       unless @license_keys.empty?
         # Licenses expiration check
-        if licenses_active?
+        # Client API possible errors will be handled in software entitlement check call (made after this)
+        # client_api_call_error is set to true when there is an error in licenses_active? call
+        if licenses_active? || client_api_call_error
           return @license_keys
         else
           # Prompts if the keys are expired or expiring
@@ -83,9 +85,9 @@ module ChefLicensing
         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
+      # Expired trial licenses and exhausted free licenses will be blocked
+      # Not blocking commercial licenses
+      if license && ((!license.expired? && !license.exhausted?) || (license.license_type.downcase == "commercial"))
         return @license_keys
       end
 
@@ -116,7 +118,8 @@ module ChefLicensing
       # 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
+      # client_api_call_error is set to true when there is an error in licenses_active? call
+      return @license_keys if (!@license_keys.empty? && licenses_active? && ChefLicensing::Context.license.license_type.downcase == "commercial") || client_api_call_error
 
       # Lowest priority is to interactively prompt if we have a TTY
       if config[:output].isatty
@@ -128,13 +131,19 @@ module ChefLicensing
           # 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
+          license ||= ChefLicensing::Context.license
+          # Expired trial licenses and exhausted free licenses will be blocked
+          # Not blocking commercial licenses
+          if (!license&.expired? && !license&.exhausted?) || (license&.license_type&.downcase == "commercial")
+            return license_keys
+          end
         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
+      # Expired trial licenses and exhausted free licenses will be blocked
+      # Not blocking commercial licenses
+      license ||= ChefLicensing::Context.license
+      if new_keys.empty? && license && ((!license.expired? && !license.exhausted?) || (license.license_type.downcase == "commercial"))
         return @license_keys
       end
 
@@ -195,6 +204,7 @@ module ChefLicensing
         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")
+        extra_info[:is_commercial] = license.license_type.downcase == "commercial"
       end
 
       unless info.empty? # ability to add info hash through arguments
@@ -212,6 +222,9 @@ module ChefLicensing
       # 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
+
+      # Cache license context
+      ChefLicensing::Context.license = license
       # Intentional lag of 2 seconds when license is expiring or expired
       sleep 2 if license.expiring_or_expired?
       spinner.success # Stop the spinner
@@ -227,7 +240,13 @@ module ChefLicensing
         config[:start_interaction] = :prompt_license_about_to_expire
         prompt_fetcher.config = config
         false
+      elsif license.exhausted? && (license.license_type.downcase == "commercial" || license.license_type.downcase == "free")
+        config[:start_interaction] = :prompt_license_exhausted
+        prompt_fetcher.config = config
+        false
       else
+        # If license is not expired or expiring, return true. But if the license is not commercial, warn the user.
+        config[:start_interaction] = :warn_non_commercial_license unless license.license_type.downcase == "commercial"
         true
       end
     rescue ChefLicensing::ClientError => e
@@ -271,8 +290,8 @@ module ChefLicensing
     end
 
     def get_license_type(license_key)
-      self.license = ChefLicensing.client(license_keys: [license_key])
-      license.license_type.downcase.to_sym
+      license_obj = ChefLicensing.client(license_keys: [license_key])
+      license_obj.license_type.downcase.to_sym
     end
 
     def license_restricted?(license_type)
@@ -283,7 +302,7 @@ module ChefLicensing
     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
+      # TODO for Free Tier 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.
@@ -294,23 +313,29 @@ module ChefLicensing
     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
+        # However, if user is trying to add Free Tier 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
+        elsif file_fetcher.user_has_active_trial_or_free_license?
+          # Handling license addition restriction scenarios only if the current license is an active license
           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
+        if existing_license_keys_in_file
+          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
         end
-        true # license type is restricted but not the key since it is the same key hence returning true
+        # license addition should be restricted but it is not because the key is same as that of one user is trying to add
+        # license addition should be restricted but it is not because the license is expired and warning wont be handled by this restriction
+        true
       else
         persist_and_concat(new_keys, license_type)
         true
       end
     end
   end
-end
+end

data/lib/chef-licensing/list_license_keys.rb

@@ -28,8 +28,11 @@ module ChefLicensing
 
       licenses_metadata.each do |license|
         puts_bold "License Key     : #{license.id}"
+        # Note: The license type is returned as "free" for Free Tier Licenses from the server.
+        # This is capitalized to "Free Tier" for display purposes as recommended by the product team.
+        license_type = license.license_type == "free" ? "Free Tier" : license.license_type.capitalize
         output.puts <<~LICENSE
-          Type            : #{license.license_type}
+          Type            : #{license_type}
           Status          : #{license.status}
           Expiration Date : #{license.expiration_date}
 
@@ -57,7 +60,10 @@ module ChefLicensing
     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.
+        # Note: The license type is returned as "free" for Free Tier Licenses from the server.
+        # This is capitalized to "Free Tier" for display purposes as recommended by the product team.
+        license_type = license.license_type == "free" ? "Free Tier" : license.license_type.capitalize
+        # Sets the validity text for a Free Tier License as "Unlimited" and displays the number of days for others.
         validity = if license.license_type == "free"
                      "Unlimited"
                    else
@@ -72,7 +78,7 @@ module ChefLicensing
             #{pastel.bold("License Details")}
               Asset Name       : #{license.limits.first.software}
               License ID       : #{license.id}
-              Type             : #{license.license_type.capitalize}
+              Type             : #{license_type}
               Status           : #{license.status.capitalize}
               Validity         : #{validity}
               No. Of Units     : #{num_of_units} #{unit_measure.capitalize.pluralize(num_of_units)}

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

@@ -7,6 +7,7 @@ require_relative "../exceptions/restful_client_connection_error"
 require_relative "../exceptions/missing_api_credentials_error"
 require_relative "../config"
 require_relative "middleware/exceptions_handler"
+require_relative "middleware/content_type_validator"
 
 module ChefLicensing
   module RestfulClient
@@ -22,6 +23,7 @@ module ChefLicensing
       }.freeze
 
       CURRENT_ENDPOINT_VERSION = 2
+      REQUEST_LIMIT = 5
 
       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?
@@ -33,14 +35,6 @@ module ChefLicensing
         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
@@ -75,53 +69,82 @@ module ChefLicensing
 
       # 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
+        response = invoke_api(ChefLicensing::Config.license_server_url.split(","), endpoint, :get, nil, params)
+        response.body
       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
+        response = invoke_api(ChefLicensing::Config.license_server_url.split(","), endpoint, :post, payload, nil, headers)
+        raise RestfulClientError, format_error_from(response) unless response.success?
+
+        response.body
+      end
+
+      def invoke_api(urls, endpoint, http_method, payload = nil, params = {}, headers = {})
+        handle_connection = http_method == :get ? method(:handle_get_connection) : method(:handle_post_connection)
+        response = nil
+        attempted_urls = []
+
+        logger.warn "Only the first #{REQUEST_LIMIT} urls will be tried." if urls.size > REQUEST_LIMIT
+        urls.each_with_index do |url, i|
+          url = url.strip
+          attempted_urls << url
+          break if i == REQUEST_LIMIT - 1
+
+          logger.debug "Trying to connect to #{url}"
+          handle_connection.call(url) do |connection|
+            response = connection.send(http_method, endpoint) do |request|
+              request.body = payload.to_json if payload
+              request.params = params if params
+              request.headers = headers if headers
+            end
           end
-          raise RestfulClientError, format_error_from(response) unless response.success?
-
-          response.body
+          # At this point, we have a successful connection
+          # Update the value of license server url in config
+          ChefLicensing::Config.license_server_url = url
+          logger.debug "Connection succeeded to #{url}"
+          break response
+        rescue RestfulClientConnectionError
+          logger.warn "Connection failed to #{url}"
+        rescue URI::InvalidURIError
+          logger.warn "Invalid URI #{url}"
         end
+
+        raise_restful_client_conn_error(attempted_urls) if response.nil?
+        response
       end
 
-      def handle_get_connection
+      def handle_get_connection(url = nil)
         # handle faraday errors
-        yield get_connection
+        yield get_connection(url)
       rescue Faraday::ClientError => e
         logger.debug "Restful Client Error #{e.message}"
         raise RestfulClientError, e.message
       end
 
-      def handle_post_connection
+      def handle_post_connection(url = nil)
         # handle faraday errors
-        yield post_connection
+        yield post_connection(url)
       rescue Faraday::ClientError => e
         logger.debug "Restful Client Error #{e.message}"
         raise RestfulClientError, e.message
       end
 
-      def get_connection
+      def get_connection(url = nil)
         store = ::ActiveSupport::Cache.lookup_store(:file_store, Dir.tmpdir)
-        Faraday.new(url: ChefLicensing::Config.license_server_url) do |config|
+        Faraday.new(url: 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.use Middleware::ContentTypeValidator
           config.adapter Faraday.default_adapter
         end
       end
 
-      def post_connection
-        Faraday.new(url: ChefLicensing::Config.license_server_url) do |config|
+      def post_connection(url = nil)
+        Faraday.new(url: url) do |config|
           config.request :json
           config.response :json, parser_options: { object_class: OpenStruct }
           config.use Middleware::ExceptionsHandler
@@ -134,6 +157,19 @@ module ChefLicensing
 
         error_details
       end
+
+      def raise_restful_client_conn_error(urls)
+        error_message = <<~EOM
+          Unable to connect to the licensing server. #{ChefLicensing::Config.chef_product_name} requires server communication to operate.
+          The following URL(s) were tried:\n#{
+            urls.each_with_index.map do |url, index|
+              "#{index + 1}. #{url}"
+            end.join("\n")
+          }
+        EOM
+
+        raise RestfulClientConnectionError, error_message
+      end
     end
   end
 end

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

@@ -0,0 +1,24 @@
+require "faraday/middleware"
+require_relative "../../../chef-licensing/exceptions/unsupported_content_type"
+
+module Middleware
+  class ContentTypeValidator < Faraday::Middleware
+    def call(env)
+      @app.call(env).on_complete do |response_env|
+        content_type = response_env[:response_headers]["content-type"]
+        body = response_env[:body]
+        # trim the body to 1000 characters to avoid printing a huge string in the error message
+        body = body[0..1000] if body.is_a?(String)
+        raise ChefLicensing::UnsupportedContentType, error_message(content_type, body) unless content_type == "application/json"
+      end
+    end
+
+    def error_message(content_type, body = nil)
+      <<~EOM
+        Expected 'application/json' content-type, but received '#{content_type}' from the licensing server.
+        Snippet of body: `#{body}`
+        Possible causes: Check for firewall restrictions, ensure proper server response, or seek support assistance.
+      EOM
+    end
+  end
+end

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

@@ -8,9 +8,7 @@ module 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
+      raise ChefLicensing::RestfulClientConnectionError, e.message
     end
   end
 end

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

@@ -6,8 +6,6 @@ module ChefLicensing
     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",