yggdrasil-engine 0.0.8.beta.1-x86_64-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a0a252217899b236f80b423d91250de6b9d911c7084382e35eaed27271e5960
+  data.tar.gz: eb329ef09fd9a021ee97c530b8efca5f622e05417812222e8a23fcb0eff05b6d
+SHA512:
+  metadata.gz: e68bbc4d7a47e8e4183a99cce8ccb790d5a7eab74fdadd9c2e66e29cbd279fe004e0c9ae641f6f56fa9a67397161d257af7eabc24e527c7d6313bc3122382865
+  data.tar.gz: 166e3a3ed8ceab2d1226fd9a04f068e47a944c86432bb4f28759d36967487ba31e40cc8b186fa70bc5676366d04e1fefb50e9037e19dd6a1d163176ea3021498

data/README.md

@@ -0,0 +1,36 @@
+# Ruby Bindings to Yggdrasil
+
+## Running the tests
+
+First make sure that you have built the native FFI code and it's located in the right place. This can be done with the build script in `build.sh`:
+
+
+```bash
+./build.sh
+```
+
+Then you can run the tests with:
+
+```bash
+rspec
+```
+
+There's also a `mem_check.rb` in the scripts folder. This is not a bullet proof test, but it can be helpful for detecting large leaks. This requires human interaction - you need to read the output and understand what it's telling you, so it's not run as part of the test suite.
+
+```bash
+ruby scripts/mem_check.rb
+```
+
+## Build
+
+You can build the gem with:
+
+```bash
+gem build yggdrasil-engine.gemspec
+```
+
+Then you can install the gem for local development with:
+
+```
+gem install yggdrasil-engine-0.0.1.gem
+```

data/lib/custom_strategy.rb

@@ -0,0 +1,60 @@
+STANDARD_STRATEGIES = [
+  "default",
+  "userWithId",
+  "gradualRolloutUserId",
+  "gradualRolloutSessionId",
+  "gradualRolloutRandom",
+  "flexibleRollout",
+  "remoteAddress",
+].freeze
+
+class CustomStrategyHandler
+  def initialize
+    @custom_strategies_definitions = {}
+    @custom_strategy_implementations = {}
+  end
+
+  def update_strategies(json_str)
+    custom_strategies = {}
+    parsed_json = JSON.parse(json_str)
+
+    parsed_json["features"].each do |feature|
+      toggle_name = feature["name"]
+      strategies = feature["strategies"]
+
+      custom_strategies_for_toggle = strategies.select do |strategy|
+        !STANDARD_STRATEGIES.include?(strategy["name"])
+      end
+
+      unless custom_strategies_for_toggle.empty?
+        custom_strategies[toggle_name] = custom_strategies_for_toggle
+      end
+    end
+
+    @custom_strategies_definitions = custom_strategies
+  end
+
+  def register_custom_strategies(strategies)
+    strategies.each do |strategy|
+      if strategy.respond_to?(:name) && strategy.name.is_a?(String) &&
+         strategy.respond_to?(:enabled?)
+        @custom_strategy_implementations[strategy.name] = strategy
+      else
+        raise "Invalid strategy object. Must have a name method that returns a String and an enabled? method."
+      end
+    end
+  end
+
+  def evaluate_custom_strategies(toggle_name, context)
+    results = {}
+
+    @custom_strategies_definitions[toggle_name]&.each_with_index do |strategy, index|
+      key = "customStrategy#{index + 1}"
+      strategy_impl = @custom_strategy_implementations[strategy["name"]]
+      result = strategy_impl&.enabled?(strategy["parameters"], context) || false
+      results[key] = result
+    end
+
+    results
+  end
+end

data/lib/libyggdrasilffi_x86_64-linux-musl.so

@@ -0,0 +1 @@
+Not Found

data/lib/yggdrasil_engine.rb

@@ -0,0 +1,145 @@
+require 'ffi'
+require 'json'
+require 'custom_strategy'
+
+TOGGLE_MISSING_RESPONSE = 'NotFound'.freeze
+ERROR_RESPONSE = 'Error'.freeze
+OK_RESPONSE = 'Ok'.freeze
+
+def platform_specific_lib
+  os = RbConfig::CONFIG['host_os']
+  cpu = RbConfig::CONFIG['host_cpu']
+
+  extension, prefix = case os
+                      when /darwin|mac os/
+                        ['dylib', 'lib']
+                      when /linux/
+                        ['so', 'lib']
+                      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                        ['dll', '']
+                      else
+                        raise "unsupported platform #{os}"
+                      end
+
+  arch_suffix = case cpu
+                when /x86_64/
+                  'x86_64'
+                when /arm|aarch64/
+                  'arm64'
+                else
+                  raise "unsupported architecture #{cpu}"
+                end
+
+  lib_type_suffix = if os =~ /linux/
+                      musl = system("ldd /bin/sh | grep -q musl") # Check if musl is in use
+                      musl ? "-musl" : ""
+                    else
+                      ""
+                    end
+
+  "#{prefix}yggdrasilffi_#{arch_suffix}#{lib_type_suffix}.#{extension}"
+end
+
+def to_variant(raw_variant)
+  payload = raw_variant[:payload] && raw_variant[:payload].transform_keys(&:to_s)
+  {
+    name: raw_variant[:name],
+    enabled: raw_variant[:enabled],
+    feature_enabled: raw_variant[:featureEnabled],
+    payload: payload,
+  }
+end
+
+class YggdrasilEngine
+  extend FFI::Library
+  ffi_lib File.expand_path(platform_specific_lib, __dir__)
+
+  attach_function :new_engine, [], :pointer
+  attach_function :free_engine, [:pointer], :void
+
+  attach_function :take_state, %i[pointer string], :pointer
+  attach_function :check_enabled, %i[pointer string string string], :pointer
+  attach_function :check_variant, %i[pointer string string string], :pointer
+  attach_function :get_metrics, [:pointer], :pointer
+  attach_function :free_response, [:pointer], :void
+
+  attach_function :count_toggle, %i[pointer string bool], :void
+  attach_function :count_variant, %i[pointer string string], :void
+
+  attach_function :list_known_toggles, [:pointer], :pointer
+
+  def initialize
+    @engine = YggdrasilEngine.new_engine
+    @custom_strategy_handler = CustomStrategyHandler.new
+    ObjectSpace.define_finalizer(self, self.class.finalize(@engine))
+  end
+
+  def self.finalize(engine)
+    proc { YggdrasilEngine.free_engine(engine) }
+  end
+
+  def take_state(toggles)
+    @custom_strategy_handler.update_strategies(toggles)
+    response_ptr = YggdrasilEngine.take_state(@engine, toggles)
+    take_toggles_response = JSON.parse(response_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_variant(name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(name, context).to_json
+
+    variant_def_json_ptr = YggdrasilEngine.check_variant(@engine, name, context_json, custom_strategy_results)
+    variant_def_json = variant_def_json_ptr.read_string
+    YggdrasilEngine.free_response(variant_def_json_ptr)
+    variant_response = JSON.parse(variant_def_json, symbolize_names: true)
+
+    return nil if variant_response[:status_code] == TOGGLE_MISSING_RESPONSE
+    variant = variant_response[:value]
+
+    return to_variant(variant) if variant_response[:status_code] == OK_RESPONSE
+  end
+
+  def enabled?(toggle_name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(toggle_name, context).to_json
+
+    response_ptr = YggdrasilEngine.check_enabled(@engine, toggle_name, context_json, custom_strategy_results)
+    response_json = response_ptr.read_string
+    YggdrasilEngine.free_response(response_ptr)
+    response = JSON.parse(response_json, symbolize_names: true)
+
+    raise "Error: #{response[:error_message]}" if response[:status_code] == ERROR_RESPONSE
+    return nil if response[:status_code] == TOGGLE_MISSING_RESPONSE
+
+    return response[:value] == true
+  end
+
+  def count_toggle(toggle_name, enabled)
+    response_ptr = YggdrasilEngine.count_toggle(@engine, toggle_name, enabled)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def count_variant(toggle_name, variant_name)
+    response_ptr = YggdrasilEngine.count_variant(@engine, toggle_name, variant_name)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_metrics
+    metrics_ptr = YggdrasilEngine.get_metrics(@engine)
+    metrics = JSON.parse(metrics_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(metrics_ptr)
+    metrics[:value]
+  end
+
+  def list_known_toggles
+    response_ptr = YggdrasilEngine.list_known_toggles(@engine)
+    response_json = response_ptr.read_string
+    YggdrasilEngine.free_response(response_ptr)
+    JSON.parse(response_json, symbolize_names: true)
+  end
+
+  def register_custom_strategies(strategies)
+    @custom_strategy_handler.register_custom_strategies(strategies)
+  end
+end

data/spec/custom_strategy_spec.rb

@@ -0,0 +1,136 @@
+require_relative '../lib/custom_strategy'
+
+RSpec.describe "custom strategies" do
+  let(:raw_state) do
+    {
+      "version": 1,
+      "features": [
+        {
+          "name": "Feature.A",
+          "enabled": true,
+          "strategies": [
+            {
+              "name": "default",
+              "parameters": {}
+            },
+            {
+              "name": "custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+            {
+              "name": "some-other-custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+          ]
+        }
+      ]
+    }
+  end
+
+  let(:handler) { CustomStrategyHandler.new }
+
+  before do
+    handler.update_strategies(raw_state.to_json)
+  end
+
+  describe 'computing custom strategies' do
+    it 'respects the logic contained in the enabled function' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(false)
+    end
+
+    it 'creates a strategy result for every custom strategy thats implemented and defined' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom"), TestStrategy.new("some-other-custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(true)
+    end
+
+    it 'returns false for missing implementations' do
+      handler.register_custom_strategies([])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(false)
+    end
+
+    it "should calculate custom strategies e2e" do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          context[:userId] == "123"
+        end
+      end
+
+      state = {
+        "version": 1,
+        "features": [
+          {
+            "name": "Feature.A",
+            "enabled": true,
+            "strategies": [
+              {
+                "name": "custom",
+                "parameters": {
+                  "gerkhins": "yes"
+                }
+              }
+            ]
+          }
+        ]
+      }
+
+      engine = YggdrasilEngine.new
+      engine.register_custom_strategies([TestStrategy.new("custom")])
+
+      engine.take_state(state.to_json)
+
+      should_be_enabled = engine.enabled?("Feature.A", {
+                                            userId: "123"
+                                          })
+
+      should_not_be_enabled = engine.enabled?("Feature.A", {
+                                                userId: "456"
+                                              })
+
+      expect(should_be_enabled).to eq(true)
+      expect(should_not_be_enabled).to eq(false)
+    end
+  end
+end

data/spec/yggdrasil_engine_spec.rb

@@ -0,0 +1,161 @@
+require 'rspec'
+require 'json'
+require_relative '../lib/yggdrasil_engine'
+
+index_file_path = '../client-specification/specifications/index.json'
+test_suites = JSON.parse(File.read(index_file_path))
+
+def test_suite_variant(base_variant)
+  payload = base_variant[:payload] && base_variant[:payload].transform_keys(&:to_s)
+  {
+    name: base_variant[:name],
+    enabled: base_variant[:enabled],
+    feature_enabled: base_variant[:feature_enabled],
+    payload: payload,
+  }
+end
+
+RSpec.describe YggdrasilEngine do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  describe '#checking a toggle' do
+    it 'that does not exist should yield a not found' do
+      is_enabled = yggdrasil_engine.enabled?('missing-toggle', {})
+      expect(is_enabled).to be_nil
+    end
+  end
+
+  describe '#metrics' do
+    it 'should clear metrics when get_metrics is called' do
+      feature_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(feature_name, true)
+      yggdrasil_engine.count_toggle(feature_name, false)
+
+      metrics = yggdrasil_engine.get_metrics() # This should clear the metrics buffer
+
+      metric = metrics[:toggles][feature_name.to_sym]
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+
+      metrics = yggdrasil_engine.get_metrics()
+      expect(metrics).to be_nil
+    end
+
+    it 'should increment toggle count when it exists' do
+      toggle_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment toggle count when the toggle does not exist' do
+      toggle_name = 'Feature.X'
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment variant' do
+      toggle_name = 'Feature.Q'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_variant(toggle_name, 'disabled')
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:variants][:disabled]).to eq(1)
+    end
+
+    it 'should list all the features that were loaded' do
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      toggles = yggdrasil_engine.list_known_toggles()
+      expect(toggles.length).to eq(3)
+    end
+  end
+end
+
+RSpec.describe 'Client Specification' do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  test_suites.each do |suite|
+    suite_path = File.join('../client-specification/specifications', suite)
+    suite_data = JSON.parse(File.read(suite_path), symbolize_names: true)
+
+    describe "Suite '#{suite}'" do
+      before(:each) do
+        yggdrasil_engine.take_state(suite_data[:state].to_json)
+      end
+
+      suite_data.fetch(:tests, []).each do |test|
+        describe "Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test[:expectedResult] }
+
+          it 'returns correct result for `is_enabled?` method' do
+            result = yggdrasil_engine.enabled?(toggle_name, context) || false
+
+            expect(result).to eq(expected_result),
+                              "Failed test '#{test['description']}': expected #{expected_result}, got #{result}"
+          end
+        end
+      end
+
+      suite_data.fetch(:variantTests, []).each do |test|
+        next unless test[:expectedResult]
+
+        describe "Variant Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test_suite_variant(test[:expectedResult]) }
+
+          it 'returns correct result for `get_variant` method' do
+            result = yggdrasil_engine.get_variant(toggle_name, context) || {
+              :name => 'disabled',
+              :payload => nil,
+              :enabled => false,
+              :feature_enabled => false
+            }
+
+            expect(result[:name]).to eq(expected_result[:name])
+            expect(result[:payload]).to eq(expected_result[:payload])
+            expect(result[:enabled]).to eq(expected_result[:enabled])
+            expect(result[:feature_enabled]).to eq(expected_result[:feature_enabled])
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: yggdrasil-engine
+version: !ruby/object:Gem::Version
+  version: 0.0.8.beta.1
+platform: x86_64-linux-musl
+authors:
+- Unleash
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.3
+description: "..."
+email: liquidwicked64@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/custom_strategy.rb
+- lib/libyggdrasilffi_x86_64-linux-musl.so
+- lib/yggdrasil_engine.rb
+- spec/custom_strategy_spec.rb
+- spec/yggdrasil_engine_spec.rb
+homepage: http://github.com/username/my_gem
+licenses:
+- MIT
+metadata:
+  yggdrasil_core_version: 0.14.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Unleash engine for evaluating feature toggles
+test_files: []