chef-licensing 0.4.43

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 964f7cfe2142120460f62fe5d859ed5a1fee820b023a66d79d9a5e993a3f83aa
+  data.tar.gz: 51459f83f1c053b6da1ef961e550951ed709e1f87cc5ff8dc8e84f2ac3a1f76d
+SHA512:
+  metadata.gz: 57a658f34d4d126b60311613f0ca6b8973fd29b3be180cc7082023c51aeef4f02ce2fa8f132e18ae2574137d97fe1da27f3ad2bd66e787d038fd4ded954d07c5
+  data.tar.gz: aaa6881007ef1f2377dfe2cce95cf46114a2743d0568e2776777d9ebafe6c49af540c29d2b97678dade43e0634dc018d89bd719f19bc6102189bb957f6f60d45

data/LICENSE

@@ -0,0 +1 @@
+Proprietary code. All rights reserved.

data/chef-licensing.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "chef-licensing/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "chef-licensing"
+  spec.version       = ChefLicensing::VERSION
+  spec.authors       = ["Inspec Team"]
+  spec.email         = ["inspec@progress.com"]
+  spec.license       = "LicenseRef-LICENSE"
+
+  spec.summary       = %q{Chef License storage, generation, and entitlement}
+  spec.description   = %q{Ruby library to support CLI tools that use Progress Chef license storage, generation, and entitlement.}
+  spec.homepage      = "https://github.com/chef/chef-licensing"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/chef/chef-licensing"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files =
+  Dir.glob("{{lib,etc}/**/*,LICENSE,chef-licensing.gemspec}")
+    .reject { |f| File.directory?(f) }
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "chef-config", ">= 15"
+  spec.add_dependency "tty-prompt", "~> 0.23"
+  spec.add_dependency "faraday", ">= 1", "< 3"
+  spec.add_dependency "faraday-http-cache"
+  spec.add_dependency "activesupport", "~> 7.0", ">= 7.0.4.2"
+  spec.add_dependency "tty-spinner", "~> 0.9.3"
+end

data/lib/chef-licensing/api/client.rb

@@ -0,0 +1,39 @@
+require_relative "../restful_client/v1"
+require_relative "../exceptions/client_error"
+require_relative "../license"
+require_relative "../config"
+
+module ChefLicensing
+  module Api
+    class Client
+      attr_reader :license_keys, :entitlement_id
+
+      class << self
+        def info(opts = {})
+          new(opts).info
+        end
+      end
+
+      def initialize(opts = {})
+        @license_keys = opts[:license_keys] || raise(ArgumentError, "Missing Params: `license_keys`")
+        @restful_client = opts[:restful_client] ? opts[:restful_client].new : ChefLicensing::RestfulClient::V1.new
+      end
+
+      def info
+        response = restful_client.client(license_keys: license_keys.join(","), entitlement_id: ChefLicensing::Config.chef_entitlement_id)
+        if response.data
+          ChefLicensing::License.new(
+            data: response.data,
+            api_parser: ChefLicensing::Api::Parser::Client
+          )
+        else
+          raise(ChefLicensing::ClientError, response.message)
+        end
+      end
+
+      private
+
+      attr_reader :restful_client
+    end
+  end
+end

data/lib/chef-licensing/api/describe.rb

@@ -0,0 +1,62 @@
+require_relative "../restful_client/v1"
+require_relative "../exceptions/describe_error"
+require_relative "../license"
+require_relative "../config"
+require "ostruct" unless defined?(OpenStruct)
+
+module ChefLicensing
+  module Api
+    class Describe
+      attr_reader :license_keys
+
+      class << self
+        def list(opts = {})
+          new(opts).list
+        end
+      end
+
+      def initialize(opts = {})
+        @license_keys = opts[:license_keys] || raise(ArgumentError, "Missing Params: `license_keys`")
+        @restful_client = opts[:restful_client] ? opts[:restful_client].new : ChefLicensing::RestfulClient::V1.new
+      end
+
+      def list
+        response_data = get_describe_api_response_data
+
+        list_of_licenses = []
+
+        response_data.license.each do |license|
+          # license object created to be fed to parser
+          license_object = OpenStruct.new({
+            "license" => license,
+            "assets" => response_data.Assets,
+            "features" => response_data.Features,
+            "software" => response_data.Software,
+          })
+
+          list_of_licenses << ChefLicensing::License.new(
+            data: license_object,
+            product_name: ChefLicensing::Config.chef_product_name,
+            api_parser: ChefLicensing::Api::Parser::Describe
+          )
+        end
+        # returns list of license data model object
+        list_of_licenses
+      end
+
+      private
+
+      attr_reader :restful_client
+
+      def get_describe_api_response_data
+        response = restful_client.describe(license_keys: license_keys.join(","), entitlement_id: ChefLicensing::Config.chef_entitlement_id)
+
+        raise(ChefLicensing::DescribeError, response.message) unless response.data
+
+        raise(ChefLicensing::DescribeError, "No license details found for the given license keys") unless response.data&.license.is_a?(Array) || response.data.license&.any?
+
+        response.data
+      end
+    end
+  end
+end

data/lib/chef-licensing/api/license_feature_entitlement.rb

@@ -0,0 +1,55 @@
+require_relative "../restful_client/v1"
+
+module ChefLicensing
+  module Api
+    class LicenseFeatureEntitlement
+      attr_reader :license_keys
+
+      class << self
+        def check_entitlement!(license_keys: [], feature_name: nil, feature_id: nil)
+          new(license_keys: license_keys, feature_name: feature_name , feature_id: feature_id).check_entitlement!
+        end
+      end
+
+      def initialize(license_keys: [], feature_name: nil, feature_id: nil, restful_client: ChefLicensing::RestfulClient::V1)
+        license_keys || raise(ArgumentError, "Missing Params: `license_keys`")
+        @license_keys = license_keys.is_a?(Array) ? license_keys : [license_keys]
+        @feature_name = feature_name
+        @feature_id = feature_id
+        raise ArgumentError, "Either of `feature_id` or `feature_name` should be provided" if feature_name.nil? && feature_id.nil?
+
+        @restful_client = restful_client.new
+      end
+
+      def check_entitlement!
+        response = make_request
+        response.data.entitled || raise(ChefLicensing::FeatureNotEntitled)
+      end
+
+      private
+
+      attr_reader :restful_client, :feature_id, :feature_name
+
+      def make_request
+        payload = build_payload
+        if feature_name
+          restful_client.feature_by_name(payload)
+        else
+          restful_client.feature_by_id(payload)
+        end
+      end
+
+      def build_payload
+        {
+          licenseIds: license_keys,
+        }.tap do |payload|
+          if feature_name
+            payload[:featureName] = feature_name
+          else
+            payload[:featureGuid] = feature_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef-licensing/api/license_software_entitlement.rb

@@ -0,0 +1,53 @@
+require_relative "../restful_client/v1"
+
+module ChefLicensing
+  module Api
+    class LicenseSoftwareEntitlement
+      attr_reader :license_keys
+
+      def self.check!(license_keys: [], software_entitlement_name: nil, software_entitlement_id: nil)
+        new(license_keys: license_keys, software_entitlement_name: software_entitlement_name, software_entitlement_id: software_entitlement_id).check!
+      end
+
+      def initialize(license_keys: [], software_entitlement_name: nil, software_entitlement_id: nil, restful_client: ChefLicensing::RestfulClient::V1)
+        @license_keys = license_keys
+        @entitlement_id = software_entitlement_id
+        @entitlement_name = software_entitlement_name
+
+        raise ArgumentError, "Either of `software_entitlement_id` or `software_entitlement_name` should be provided" if software_entitlement_name.nil? && software_entitlement_id.nil?
+
+        @restful_client = restful_client.new
+      end
+
+      def check!
+        response = make_request
+        response.data.entitled || raise(ChefLicensing::SoftwareNotEntitled)
+      end
+
+      private
+
+      attr_reader :restful_client, :entitlement_id, :entitlement_name
+
+      def make_request
+        payload = build_payload
+        if entitlement_name
+          restful_client.entitlement_by_name(payload)
+        else
+          restful_client.entitlement_by_id(payload)
+        end
+      end
+
+      def build_payload
+        {
+          licenseIds: license_keys,
+        }.tap do |payload|
+          if entitlement_name
+            payload[:entitlementName] = entitlement_name
+          else
+            payload[:entitlementGuid] = entitlement_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef-licensing/api/list_licenses.rb

@@ -0,0 +1,30 @@
+require_relative "../restful_client/v1"
+require_relative "../exceptions/list_licenses_error"
+require_relative "../config"
+
+module ChefLicensing
+  module Api
+    class ListLicenses
+      class << self
+        def info(opts = {})
+          new(opts).info
+        end
+      end
+
+      def initialize(opts = {})
+        @restful_client = opts[:restful_client] ? opts[:restful_client].new : ChefLicensing::RestfulClient::V1.new
+      end
+
+      def info
+        response = restful_client.list_licenses
+        raise ChefLicensing::ListLicensesError.new(response.message, response.status_code) unless response.status_code == 200 && response.data
+
+        response.data
+      end
+
+      private
+
+      attr_reader :restful_client
+    end
+  end
+end

data/lib/chef-licensing/api/parser/client.rb

@@ -0,0 +1,100 @@
+require "ostruct" unless defined?(OpenStruct)
+module ChefLicensing
+  module Api
+    module Parser
+      class Client
+
+        # Uses response from /client API
+        # This parser formats the response which will enable creation of license data object.
+
+        attr_reader :data, :client_data
+
+        def initialize(data)
+          # API call response
+          @data = data
+          @client_data = data.client || OpenStruct.new({})
+        end
+
+        def parse_id
+          nil
+        end
+
+        def parse_license_type
+          client_data.license
+        end
+
+        def parse_status
+          client_data.status
+        end
+
+        # Parse expiration details
+
+        def parse_expiration_date
+          client_data.changesOn
+        end
+
+        def parse_license_expiration_status
+          client_data.changesTo
+        end
+
+        # Parse usage details
+        def parse_limits
+          if data.client.nil? || data.client.empty?
+            []
+          else
+            [{
+              "usage_status" => client_data.usage,
+              "usage_limit" => client_data.limit,
+              "usage_measure" => client_data.measure,
+              "used" => client_data.used,
+            }]
+          end
+        end
+
+        # Parse entitlements
+
+        def parse_feature_entitlements
+          features = []
+          features_data = data.features || []
+          features_data.each do |feature|
+            feature_info = {
+              "id" => feature.id,
+              "name" => feature.name,
+            }
+            features << feature_info
+          end
+          features
+        end
+
+        def parse_software_entitlements
+          if data.entitlement.nil? || data.entitlement.empty?
+            []
+          else
+            require "date"
+            entitlement_status = (data.entitlement.end >= Date.today.to_s) ? "Active" : "Expired"
+            # sending status based on end date
+            [{
+              "id" => data.entitlement.id,
+              "name" => data.entitlement.name,
+              "entitled" => data.entitlement.entitled,
+              "status" => entitlement_status,
+            }]
+          end
+        end
+
+        def parse_asset_entitlements
+          assets = []
+          assets_data = data.assets || []
+          assets_data.each do |asset|
+            asset_info = {
+              "id" => asset.id,
+              "name" => asset.name,
+            }
+            assets << asset_info
+          end
+          assets
+        end
+      end
+    end
+  end
+end

data/lib/chef-licensing/api/parser/describe.rb

@@ -0,0 +1,118 @@
+require "ostruct" unless defined?(OpenStruct)
+module ChefLicensing
+  module Api
+    module Parser
+      class Describe
+
+        # Uses response from /describe API
+        # This parser formats the response which will enable creation of license data object.
+
+        attr_reader :data, :license_data
+
+        def initialize(data)
+          @data = data
+          @license_data = data.license || OpenStruct.new({})
+        end
+
+        def parse_id
+          license_data.licenseKey
+        end
+
+        def parse_license_type
+          license_data.licenseType
+        end
+
+        def parse_status
+          license_data.status
+        end
+
+        # Parse expiration details
+
+        def parse_expiration_date
+          license_data.end
+        end
+
+        def parse_license_expiration_status
+          nil
+        end
+
+        # Parse usage details
+
+        def parse_limits
+          limits = []
+          limits_data = license_data.limits || []
+          limits_data.each do |limit|
+            limit_details = {
+              "usage_status" => limit.status,
+              "usage_limit" => limit.amount,
+              "usage_measure" => limit.measure,
+              "used" => limit.used,
+              "software" => limit.software,
+            }
+            limits << limit_details
+          end
+          limits
+        end
+
+        # Parse entitlements
+
+        def parse_feature_entitlements
+          features = []
+          features_data = data.features || []
+          features_data.each do |feature|
+            feature.from.each do |from_info|
+              if from_info.license == parse_id
+                feature_details = {
+                  "status" => from_info.status,
+                  "entitled" => feature.entitled,
+                  "id" => feature.id,
+                  "name" => feature.name,
+                }
+                features << feature_details
+              end
+            end
+          end
+          features
+        end
+
+        def parse_software_entitlements
+          softwares = []
+          softwares_data = data.software || []
+          softwares_data.select do |software|
+            software.from.each do |from_info|
+              if from_info.license == parse_id
+                software_details = {
+                  "status" => from_info.status,
+                  "entitled" => software.entitled,
+                  "id" => software.id,
+                  "name" => software.name,
+                }
+                softwares << software_details
+              end
+            end
+          end
+          softwares
+        end
+
+        def parse_asset_entitlements
+          assets = []
+          assets_data = data.assets || []
+          assets_data.select do |asset|
+            asset.from.each do |from_info|
+              if from_info.license == parse_id
+                asset_details = {
+                  "status" => from_info.status,
+                  "entitled" => asset.entitled,
+                  "id" => asset.id,
+                  "name" => asset.name,
+                }
+                assets << asset_details
+              end
+            end
+          end
+          assets
+        end
+      end
+    end
+  end
+end

data/lib/chef-licensing/cli_flags/mixlib_cli.rb

@@ -0,0 +1,28 @@
+begin
+  require "mixlib/cli" unless defined?(Mixlib::CLI)
+rescue
+  raise "Must have mixlib-cli gem installed to use this mixin"
+end
+
+module ChefLicensing
+  module CLIFlags
+
+    module MixlibCLI
+
+      def self.included(klass)
+        # TBD need to confirm the name of the option
+        klass.option :chef_license_key,
+          long: "--chef-license-key KEY",
+          description: "Add a new Chef License Key to the license store. Ignores duplicates (not applicable to local licensing service)",
+          required: false
+
+        klass.option :chef_license_server,
+          long: "--chef-license-server URL",
+          description: "Add a custom Chef License Server URL. Overrides the global license server URL.",
+          required: false
+      end
+
+    end
+
+  end
+end

data/lib/chef-licensing/cli_flags/thor.rb

@@ -0,0 +1,21 @@
+begin
+  require "thor" unless defined?(Thor)
+rescue
+  raise "Must have thor gem installed to use this mixin"
+end
+
+module ChefLicensing
+  module CLIFlags
+    module Thor
+      def self.included(klass)
+        # TBD need to confirm the name of the option
+        klass.class_option :chef_license_key,
+          type: :string,
+          desc: "Add a new Chef License Key to the license store. Ignores duplicates (not applicable to local licensing service)"
+        klass.class_option :chef_license_server,
+          type: :string,
+          desc: "Add a custom Chef License Server URL. Overrides the global license server URL."
+      end
+    end
+  end
+end

data/lib/chef-licensing/config.rb

@@ -0,0 +1,44 @@
+require "singleton" unless defined?(Singleton)
+require "logger"
+require_relative "config_fetcher/arg_fetcher"
+require_relative "config_fetcher/env_fetcher"
+require_relative "license_key_fetcher/file"
+
+# Config class handles all configuration related to chef-licensing
+# Values can be set via block, environment variable or command line argument
+
+# Licensing service detection
+require_relative "licensing_service/local"
+
+module ChefLicensing
+  class Config
+    class << self
+      attr_writer :license_server_url, :logger, :output, :license_server_url_check_in_file
+
+      # is_local_license_service is used by context class
+      attr_accessor :is_local_license_service, :chef_entitlement_id, :chef_product_name, :chef_executable_name
+
+      def license_server_url(opts = {})
+        return @license_server_url if @license_server_url && @license_server_url_check_in_file
+
+        license_server_url_from_system = ChefLicensing::ArgFetcher.fetch_value("--chef-license-server", :string) || ChefLicensing::EnvFetcher.fetch_value("CHEF_LICENSE_SERVER", :string)
+
+        @license_server_url = ChefLicensing::LicenseKeyFetcher::File.fetch_or_persist_url(@license_server_url, license_server_url_from_system, opts)
+        @license_server_url_check_in_file = true
+        @license_server_url
+      end
+
+      def logger
+        return @logger if @logger
+
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::INFO
+        @logger
+      end
+
+      def output
+        @output ||= STDOUT
+      end
+    end
+  end
+end

data/lib/chef-licensing/config_fetcher/arg_fetcher.rb

@@ -0,0 +1,38 @@
+module ChefLicensing
+  class ArgFetcher
+
+    def initialize(argv = ARGV)
+      @argv = argv
+    end
+
+    def fetch_value(arg_name, arg_type = :string)
+      case arg_type
+      when :boolean
+        @argv.include?(arg_name)
+      when :string
+        # TODO: Refactor this code to use some library in near future
+        # There were some issues with OptionParser, so we are using this
+        # custom code for now.
+
+        # Currently, we are supporting two ways of passing arguments:
+        # 1. --chef-license-server foo
+        # 2. --chef-license-server=foo
+
+        # Check if argument is passed as: --chef-license-server foo
+        arg_value = @argv.include?(arg_name) ? @argv[@argv.index(arg_name) + 1] : nil
+
+        # Check if argument is passed as: --chef-license-server=foo
+        # only if arg_value is nil
+        if arg_value.nil?
+          arg_value = @argv.select { |arg| arg.start_with?("#{arg_name}=") }.first
+          arg_value = arg_value.split("=").last if arg_value
+        end
+        arg_value
+      end
+    end
+
+    def self.fetch_value(arg_name, arg_type = :string)
+      new.fetch_value(arg_name, arg_type)
+    end
+  end
+end

data/lib/chef-licensing/config_fetcher/env_fetcher.rb

@@ -0,0 +1,21 @@
+module ChefLicensing
+  class EnvFetcher
+
+    def initialize(env = ENV)
+      @env = env
+    end
+
+    def fetch_value(env_name, env_type = :string)
+      case env_type
+      when :boolean
+        @env.key?(env_name)
+      when :string
+        @env.fetch(env_name, nil)
+      end
+    end
+
+    def self.fetch_value(env_name, env_type = :string)
+      new.fetch_value(env_name, env_type)
+    end
+  end
+end