evoleap-licensing 1.0.0.12

data/lib/evoleap_licensing/state/server_state.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "time"
+
+module EvoleapLicensing
+  class ServerState
+    attr_accessor :instance_guid, :first_launch_time, :registered_at,
+                  :grace_period_for_validation_failures,
+                  :last_successful_validation_time, :last_validation_status,
+                  :number_of_failed_validation_attempts, :features
+
+    attr_reader :failed_registration_times, :failed_validation_times
+
+    def initialize(hash = nil)
+      hash = (hash || {}).transform_keys(&:to_s)
+      @instance_guid = hash["instance_guid"]
+      @first_launch_time = parse_time(hash["first_launch_time"])
+      @registered_at = parse_time(hash["registered_at"])
+      @grace_period_for_validation_failures = hash["grace_period_for_validation_failures"]
+      @last_successful_validation_time = parse_time(hash["last_successful_validation_time"])
+      @last_validation_status = hash["last_validation_status"]
+      @number_of_failed_validation_attempts = hash["number_of_failed_validation_attempts"] || 0
+      @features = hash["features"] || []
+      @failed_registration_times = (hash["failed_registration_times"] || []).map { |t| parse_time(t) }.compact
+      @failed_validation_times = (hash["failed_validation_times"] || []).map { |t| parse_time(t) }.compact
+    end
+
+    def registered?
+      !@registered_at.nil?
+    end
+
+    def add_registration_failure(time = Time.now.utc)
+      @failed_registration_times.unshift(time)
+    end
+
+    def reset_registration_failures
+      @failed_registration_times = []
+    end
+
+    def add_validation_failure(time = Time.now.utc)
+      @failed_validation_times.unshift(time)
+    end
+
+    def reset_validation_failures
+      @failed_validation_times = []
+      @number_of_failed_validation_attempts = 0
+    end
+
+    def take_registration_params(response)
+      @instance_guid = response["instance_guid"]
+    end
+
+    def to_h
+      {
+        "instance_guid" => @instance_guid,
+        "first_launch_time" => @first_launch_time&.iso8601,
+        "registered_at" => @registered_at&.iso8601,
+        "grace_period_for_validation_failures" => @grace_period_for_validation_failures,
+        "last_successful_validation_time" => @last_successful_validation_time&.iso8601,
+        "last_validation_status" => @last_validation_status,
+        "number_of_failed_validation_attempts" => @number_of_failed_validation_attempts,
+        "features" => @features,
+        "failed_registration_times" => @failed_registration_times.map(&:iso8601),
+        "failed_validation_times" => @failed_validation_times.map(&:iso8601)
+      }
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      return value if value.is_a?(Time)
+      Time.parse(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/evoleap_licensing/state/session_state.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  class SessionState
+    attr_accessor :auth_token, :session_key, :session_duration,
+                  :features, :feature_groups,
+                  :components, :component_entitlements
+
+    def initialize(hash = nil)
+      hash = (hash || {}).transform_keys(&:to_s)
+      @auth_token = hash["auth_token"]
+      @session_key = hash["session_key"]
+      @session_duration = hash["session_duration"]
+      @features = hash["features"] || []
+      @feature_groups = hash["feature_groups"] || []
+      @components = hash["components"] || []
+      @component_entitlements = hash["component_entitlements"] || []
+    end
+
+    def active?
+      !@auth_token.nil? && !@session_key.nil?
+    end
+
+    def clear!
+      @auth_token = nil
+      @session_key = nil
+      @session_duration = nil
+      @features = []
+      @feature_groups = []
+      @components = []
+      @component_entitlements = []
+    end
+
+    def update_from_session_response(response)
+      @auth_token = response["token"] if response["token"]
+      @session_key = response["session_key"] if response["session_key"]
+      @session_duration = response["session_duration"] if response["session_duration"]
+      @features = response["features"] if response["features"]
+      @feature_groups = response["feature_groups"] if response["feature_groups"]
+      update_components_from_response(response)
+    end
+
+    def update_from_extend_response(response)
+      @auth_token = response["token"] if response["token"]
+      @session_duration = response["session_duration"] if response["session_duration"]
+      @features = response["features"] if response["features"]
+      @feature_groups = response["feature_groups"] if response["feature_groups"]
+      update_components_from_response(response)
+    end
+
+    def update_components_from_response(response)
+      @components = response["components"] if response["components"]
+      @component_entitlements = response["component_entitlements"] if response["component_entitlements"]
+    end
+
+    def to_h
+      {
+        "auth_token" => @auth_token,
+        "session_key" => @session_key,
+        "session_duration" => @session_duration,
+        "features" => @features,
+        "feature_groups" => @feature_groups,
+        "components" => @components,
+        "component_entitlements" => @component_entitlements
+      }
+    end
+  end
+end

data/lib/evoleap_licensing/state/user_state.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "time"
+
+module EvoleapLicensing
+  class UserState
+    attr_accessor :user_guid, :first_launch_time, :registered_at,
+                  :grace_period_for_validation_failures,
+                  :last_successful_validation_time, :last_validation_status,
+                  :number_of_failed_validation_attempts, :features
+
+    attr_reader :failed_registration_times, :failed_validation_times
+
+    def initialize(hash = nil)
+      hash = (hash || {}).transform_keys(&:to_s)
+      @user_guid = hash["user_guid"]
+      @first_launch_time = parse_time(hash["first_launch_time"])
+      @registered_at = parse_time(hash["registered_at"])
+      @grace_period_for_validation_failures = hash["grace_period_for_validation_failures"]
+      @last_successful_validation_time = parse_time(hash["last_successful_validation_time"])
+      @last_validation_status = hash["last_validation_status"]
+      @number_of_failed_validation_attempts = hash["number_of_failed_validation_attempts"] || 0
+      @features = hash["features"] || []
+      @failed_registration_times = (hash["failed_registration_times"] || []).map { |t| parse_time(t) }.compact
+      @failed_validation_times = (hash["failed_validation_times"] || []).map { |t| parse_time(t) }.compact
+    end
+
+    def registered?
+      !@registered_at.nil?
+    end
+
+    def add_registration_failure(time = Time.now.utc)
+      @failed_registration_times.unshift(time)
+    end
+
+    def reset_registration_failures
+      @failed_registration_times = []
+    end
+
+    def add_validation_failure(time = Time.now.utc)
+      @failed_validation_times.unshift(time)
+    end
+
+    def reset_validation_failures
+      @failed_validation_times = []
+      @number_of_failed_validation_attempts = 0
+    end
+
+    def take_registration_params(response)
+      @user_guid = response["user_guid"]
+    end
+
+    def to_h
+      {
+        "user_guid" => @user_guid,
+        "first_launch_time" => @first_launch_time&.iso8601,
+        "registered_at" => @registered_at&.iso8601,
+        "grace_period_for_validation_failures" => @grace_period_for_validation_failures,
+        "last_successful_validation_time" => @last_successful_validation_time&.iso8601,
+        "last_validation_status" => @last_validation_status,
+        "number_of_failed_validation_attempts" => @number_of_failed_validation_attempts,
+        "features" => @features,
+        "failed_registration_times" => @failed_registration_times.map(&:iso8601),
+        "failed_validation_times" => @failed_validation_times.map(&:iso8601)
+      }
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      return value if value.is_a?(Time)
+      Time.parse(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/evoleap_licensing/types/component_license_model.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  module ComponentLicenseModel
+    NONE = :none
+    TOKEN = :token
+    SESSION = :session
+    CONSUMABLE_TOKEN = :consumable_token
+    UNKNOWN = :unknown
+
+    FROM_STRING = {
+      "None" => NONE,
+      "Token" => TOKEN,
+      "Session" => SESSION,
+      "ConsumableToken" => CONSUMABLE_TOKEN
+    }.freeze
+
+    def self.from_string(str)
+      FROM_STRING[str] || UNKNOWN
+    end
+  end
+end

data/lib/evoleap_licensing/types/invalid_reason.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  module InvalidReason
+    REGISTRATION_REQUIRED = :registration_required
+    USER_TAMPERING_DETECTED = :user_tampering_detected
+    SERVICE_UNREACHABLE = :service_unreachable
+    LICENSE_EXPIRED = :license_expired
+    INSTANCE_DISABLED = :instance_disabled
+    USER_DISABLED = :user_disabled
+    INVALID_LICENSE_KEY = :invalid_license_key
+    INVALID_PRODUCT_ID = :invalid_product_id
+    INSTANCE_NOT_REGISTERED = :instance_not_registered
+    USER_NOT_REGISTERED = :user_not_registered
+    INCONSISTENT_REGISTRATION = :inconsistent_registration
+    INCONSISTENT_USER = :inconsistent_user
+    NO_SEATS_AVAILABLE = :no_seats_available
+    SESSION_REVOKED = :session_revoked
+    ACTIVATION_PENDING = :activation_pending
+    INSUFFICIENT_TOKENS = :insufficient_tokens
+    INVALID_COMPONENT = :invalid_component
+
+    # Map ValidationStatus integers to InvalidReason symbols
+    FROM_VALIDATION_STATUS = {
+      ValidationStatus::REGISTRATION_REQUIRED => REGISTRATION_REQUIRED,
+      ValidationStatus::USER_TAMPERING_DETECTED => USER_TAMPERING_DETECTED,
+      ValidationStatus::SERVICE_UNREACHABLE => SERVICE_UNREACHABLE,
+      ValidationStatus::LICENSE_EXPIRED => LICENSE_EXPIRED,
+      ValidationStatus::INSTANCE_DISABLED => INSTANCE_DISABLED,
+      ValidationStatus::USER_DISABLED => USER_DISABLED,
+      ValidationStatus::INVALID_LICENSE_KEY => INVALID_LICENSE_KEY,
+      ValidationStatus::INVALID_PRODUCT_ID => INVALID_PRODUCT_ID,
+      ValidationStatus::INSTANCE_NOT_REGISTERED => INSTANCE_NOT_REGISTERED,
+      ValidationStatus::USER_NOT_REGISTERED => USER_NOT_REGISTERED,
+      ValidationStatus::INCONSISTENT_REGISTRATION => INCONSISTENT_REGISTRATION,
+      ValidationStatus::INCONSISTENT_USER => INCONSISTENT_USER,
+      ValidationStatus::NO_SEATS_AVAILABLE => NO_SEATS_AVAILABLE,
+      ValidationStatus::SESSION_REVOKED => SESSION_REVOKED,
+      ValidationStatus::ACTIVATION_PENDING => ACTIVATION_PENDING,
+      ValidationStatus::INSUFFICIENT_TOKENS => INSUFFICIENT_TOKENS,
+      ValidationStatus::INVALID_COMPONENT => INVALID_COMPONENT,
+      ValidationStatus::GENERAL_ERROR => SERVICE_UNREACHABLE
+    }.freeze
+
+    def self.from_validation_status(status)
+      FROM_VALIDATION_STATUS[status] || SERVICE_UNREACHABLE
+    end
+  end
+end

data/lib/evoleap_licensing/types/validation_status.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  module ValidationStatus
+    # Client-only statuses
+    REGISTRATION_REQUIRED = -101
+    USER_TAMPERING_DETECTED = -100
+    SERVICE_UNREACHABLE = -99
+
+    # Server-provided statuses
+    FULL_LICENSE_ALREADY_CHECKED_OUT = -17
+    OFFLINE_CHECKOUT_NOT_SUPPORTED = -16
+    INVALID_COMPONENT = -15
+    INSUFFICIENT_TOKENS = -14
+    ACTIVATION_PENDING = -13
+    SESSION_REVOKED = -12
+    NO_SEATS_AVAILABLE = -11
+    INCONSISTENT_REGISTRATION = -10
+    INCONSISTENT_USER = -9
+    INSTANCE_NOT_REGISTERED = -8
+    USER_NOT_REGISTERED = -7
+    INVALID_LICENSE_KEY = -6
+    INVALID_PRODUCT_ID = -5
+    INSTANCE_DISABLED = -4
+    USER_DISABLED = -3
+    LICENSE_EXPIRED = -2
+    GENERAL_ERROR = -1
+    SUCCESS = 0
+
+    ALL = {
+      registration_required: REGISTRATION_REQUIRED,
+      user_tampering_detected: USER_TAMPERING_DETECTED,
+      service_unreachable: SERVICE_UNREACHABLE,
+      full_license_already_checked_out: FULL_LICENSE_ALREADY_CHECKED_OUT,
+      offline_checkout_not_supported: OFFLINE_CHECKOUT_NOT_SUPPORTED,
+      invalid_component: INVALID_COMPONENT,
+      insufficient_tokens: INSUFFICIENT_TOKENS,
+      activation_pending: ACTIVATION_PENDING,
+      session_revoked: SESSION_REVOKED,
+      no_seats_available: NO_SEATS_AVAILABLE,
+      inconsistent_registration: INCONSISTENT_REGISTRATION,
+      inconsistent_user: INCONSISTENT_USER,
+      instance_not_registered: INSTANCE_NOT_REGISTERED,
+      user_not_registered: USER_NOT_REGISTERED,
+      invalid_license_key: INVALID_LICENSE_KEY,
+      invalid_product_id: INVALID_PRODUCT_ID,
+      instance_disabled: INSTANCE_DISABLED,
+      user_disabled: USER_DISABLED,
+      license_expired: LICENSE_EXPIRED,
+      general_error: GENERAL_ERROR,
+      success: SUCCESS
+    }.freeze
+
+    BY_VALUE = ALL.invert.freeze
+
+    def self.name_for(value)
+      BY_VALUE[value]
+    end
+
+    # Convenience class methods matching old Enum API
+    def self.registration_required; REGISTRATION_REQUIRED; end
+    def self.user_tampering_detected; USER_TAMPERING_DETECTED; end
+    def self.service_unreachable; SERVICE_UNREACHABLE; end
+    def self.activation_pending; ACTIVATION_PENDING; end
+    def self.session_revoked; SESSION_REVOKED; end
+    def self.no_seats_available; NO_SEATS_AVAILABLE; end
+    def self.inconsistent_registration; INCONSISTENT_REGISTRATION; end
+    def self.inconsistent_user; INCONSISTENT_USER; end
+    def self.instance_not_registered; INSTANCE_NOT_REGISTERED; end
+    def self.user_not_registered; USER_NOT_REGISTERED; end
+    def self.invalid_license_key; INVALID_LICENSE_KEY; end
+    def self.invalid_product_id; INVALID_PRODUCT_ID; end
+    def self.instance_disabled; INSTANCE_DISABLED; end
+    def self.user_disabled; USER_DISABLED; end
+    def self.license_expired; LICENSE_EXPIRED; end
+    def self.general_error; GENERAL_ERROR; end
+    def self.success; SUCCESS; end
+    def self.insufficient_tokens; INSUFFICIENT_TOKENS; end
+    def self.invalid_component; INVALID_COMPONENT; end
+    def self.offline_checkout_not_supported; OFFLINE_CHECKOUT_NOT_SUPPORTED; end
+    def self.full_license_already_checked_out; FULL_LICENSE_ALREADY_CHECKED_OUT; end
+
+    def self.success?(value)
+      value == SUCCESS
+    end
+
+    def self.client_only?(value)
+      value <= SERVICE_UNREACHABLE
+    end
+  end
+end

data/lib/evoleap_licensing/user_control_manager.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  class UserControlManager
+    attr_reader :product_id, :version, :instance_id, :public_key,
+                :strategy, :user_state, :session_state
+
+    def initialize(product_id:, version:, instance_id:, public_key:,
+                   strategy: nil, user_state: nil, session_state: nil)
+      @product_id = product_id
+      @version = version
+      @instance_id = instance_id
+      @public_key = public_key
+      @strategy = strategy || ControlStrategy.default
+      @user_state = user_state || UserState.new
+      @session_state = session_state || SessionState.new
+      @client = WebClient.new
+    end
+
+    # Register a user against the server instance.
+    # Returns a RegistrationResult.
+    def register(user_info:, user_identity:)
+      ControlManagerHelper.register(@user_state) do
+        WebService.register_user(
+          product_id: @product_id,
+          instance_id: @instance_id,
+          user_info: user_info,
+          user_identity: user_identity.to_api_format,
+          public_key: @public_key,
+          client: @client
+        )
+      end
+    end
+
+    # Begin or extend a user session.
+    # Returns a SessionValidity.
+    def validate_session(user_identity:, requested_duration: nil)
+      ControlManagerHelper.validate_session(@strategy, @user_state, @session_state,
+        -> { make_session_call(user_identity, requested_duration) })
+    end
+
+    # End the active session.
+    def end_session
+      raise NoActiveSessionError, "No active session to end" unless @session_state.active?
+
+      response = WebService.end_session(
+        product_id: @product_id,
+        auth_token: @session_state.auth_token,
+        session_key: @session_state.session_key,
+        public_key: @public_key,
+        client: @client
+      )
+
+      @session_state.clear!
+      !response.key?("error")
+    end
+
+    # Check out named components for the active session.
+    # Returns a ComponentCheckoutResult.
+    def check_out_components(*component_names)
+      raise NoActiveSessionError, "No active session" unless @session_state.active?
+
+      response = WebService.check_out_components(
+        product_id: @product_id,
+        auth_token: @session_state.auth_token,
+        session_key: @session_state.session_key,
+        component_names: component_names.flatten,
+        public_key: @public_key,
+        client: @client
+      )
+
+      if response["status"] == ValidationStatus::SUCCESS
+        @session_state.update_components_from_response(response)
+        ComponentCheckoutResult.new(
+          success: true,
+          components: response["components"] || [],
+          component_entitlements: response["component_entitlements"] || []
+        )
+      else
+        ComponentCheckoutResult.new(
+          success: false,
+          failure_reason: InvalidReason.from_validation_status(response["status"])
+        )
+      end
+    end
+
+    # Check in named components.
+    # Returns a ComponentCheckinResult.
+    def check_in_components(*component_names)
+      raise NoActiveSessionError, "No active session" unless @session_state.active?
+
+      response = WebService.check_in_components(
+        product_id: @product_id,
+        auth_token: @session_state.auth_token,
+        session_key: @session_state.session_key,
+        component_names: component_names.flatten,
+        public_key: @public_key,
+        client: @client
+      )
+
+      if response["status"] == ValidationStatus::SUCCESS
+        @session_state.update_components_from_response(response)
+        ComponentCheckinResult.new(success: true)
+      else
+        ComponentCheckinResult.new(
+          success: false,
+          failure_reason: InvalidReason.from_validation_status(response["status"])
+        )
+      end
+    end
+
+    # Get status of all components.
+    # Returns a ComponentsStatus.
+    def components_status
+      raise NoActiveSessionError, "No active session" unless @session_state.active?
+
+      response = WebService.components_status(
+        product_id: @product_id,
+        auth_token: @session_state.auth_token,
+        session_key: @session_state.session_key,
+        public_key: @public_key,
+        client: @client
+      )
+
+      if response["status"] == ValidationStatus::SUCCESS
+        ComponentsStatus.new(
+          success: true,
+          components: response["components"] || [],
+          component_entitlements: response["component_entitlements"] || []
+        )
+      else
+        ComponentsStatus.new(
+          success: false,
+          error_message: response["error"]
+        )
+      end
+    end
+
+    # Get license info for the active session.
+    # Returns a LicenseInfo.
+    def license_info
+      raise NoActiveSessionError, "No active session" unless @session_state.active?
+
+      response = WebService.get_license_info(
+        product_id: @product_id,
+        auth_token: @session_state.auth_token,
+        session_key: @session_state.session_key,
+        public_key: @public_key,
+        client: @client
+      )
+
+      if response["status"] == ValidationStatus::SUCCESS
+        LicenseInfo.new(
+          success: true,
+          owner_name: response["owner_name"],
+          owner_logo_url: response["owner_logo_url"],
+          expiry: response["expiry"]
+        )
+      else
+        LicenseInfo.new(
+          success: false,
+          error_message: response["error"]
+        )
+      end
+    end
+
+    # For testing: allow injecting a custom web client
+    def web_client=(client)
+      @client = client
+    end
+
+    private
+
+    def make_session_call(user_identity, requested_duration)
+      if @session_state.active?
+        # Extend existing session
+        WebService.extend_session(
+          product_id: @product_id,
+          auth_token: @session_state.auth_token,
+          session_key: @session_state.session_key,
+          public_key: @public_key,
+          client: @client,
+          session_duration: requested_duration
+        )
+      else
+        # Begin new session
+        WebService.begin_user_session(
+          product_id: @product_id,
+          instance_id: @instance_id,
+          user_identity: user_identity.to_api_format,
+          public_key: @public_key,
+          client: @client,
+          session_duration: requested_duration
+        )
+      end
+    end
+  end
+end

data/lib/evoleap_licensing/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EvoleapLicensing
+  VERSION = "1.0.0.12"
+end
+

data/lib/evoleap_licensing/web_client.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module EvoleapLicensing
+  class WebClient
+    ENDPOINTS = {
+      register_instance: "register_instance",
+      validate_instance: "validate_instance",
+      register_user: "register_user",
+      begin_user_session: "begin_user_session",
+      extend_session: "extend_session",
+      end_session: "end_session",
+      check_out_components: "check_out_components",
+      check_in_components: "check_in_components",
+      components_status: "components_status",
+      get_license_info: "get_license_info"
+    }.freeze
+
+    attr_accessor :base_url, :timeout
+
+    def initialize(base_url: nil, timeout: nil)
+      config = EvoleapLicensing.configuration
+      @base_url = base_url || config.api_base_url
+      @timeout = timeout || config.timeout
+    end
+
+    ENDPOINTS.each do |method_name, _endpoint|
+      define_method(method_name) do |key, encrypted_params|
+        post(method_name, key, encrypted_params)
+      end
+    end
+
+    private
+
+    def post(action, key, encrypted_params)
+      url = URI("#{@base_url}/#{ENDPOINTS[action]}")
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+
+      request = Net::HTTP::Post.new(url)
+      request["Content-Type"] = "application/json"
+      request["User-Agent"] = EvoleapLicensing.configuration.user_agent
+      request.body = { key: key, data: encrypted_params }.to_json
+
+      response = http.request(request)
+
+      case response
+      when Net::HTTPSuccess
+        response.body
+      when Net::HTTPInternalServerError
+        raise ServerError, "Server error: #{response.code} #{response.message}"
+      else
+        raise ApiError, "API error: #{response.code} #{response.message}"
+      end
+    end
+
+    class ServerError < EvoleapLicensing::Error; end
+    class ApiError < EvoleapLicensing::Error; end
+  end
+end