prefab-cloud-ruby 0 → 0.0.1

data/lib/prefab/config_client.rb

@@ -1,292 +1,40 @@
-# frozen_string_literal: true
-
 module Prefab
   class ConfigClient
-    RECONNECT_WAIT = 5
-    DEFAULT_CHECKPOINT_FREQ_SEC = 60
-    SSE_READ_TIMEOUT = 300
-    STALE_CACHE_WARN_HOURS = 5
-    AUTH_USER = 'authuser'
-    LOGGING_KEY_PREFIX = "#{Prefab::LoggerClient::BASE_KEY}#{Prefab::LoggerClient::SEP}".freeze
-    LOG = Prefab::InternalLogger.new(ConfigClient)
-
-    def initialize(base_client, timeout)
-      @base_client = base_client
-      @options = base_client.options
-      LOG.debug 'Initialize ConfigClient'
-      @timeout = timeout
-
-      @stream_lock = Concurrent::ReadWriteLock.new
-
-      @checkpoint_freq_secs = DEFAULT_CHECKPOINT_FREQ_SEC
-
-      @config_loader = Prefab::ConfigLoader.new(@base_client)
-      @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
-
-      @initialization_lock = Concurrent::ReadWriteLock.new
-      LOG.debug 'Initialize ConfigClient: AcquireWriteLock'
-      @initialization_lock.acquire_write_lock
-      LOG.debug 'Initialize ConfigClient: AcquiredWriteLock'
-      @initialized_future = Concurrent::Future.execute { @initialization_lock.acquire_read_lock }
-
-      if @options.local_only?
-        finish_init!(:local_only, nil)
-      elsif @options.datafile?
-        load_json_file(@options.datafile)
-      else
-        load_checkpoint
-        start_checkpointing_thread
-        start_streaming
-      end
-    end
-
-    def start_streaming
-      @stream_lock.with_write_lock do
-        start_sse_streaming_connection_thread(@config_loader.highwater_mark) if @streaming_thread.nil?
-      end
-    end
-
-    def to_s
-      @config_resolver.to_s
-    end
-
-    def resolver
-      @config_resolver
+    def initialize(config_service, client)
+      @client = client
+      @config_service = config_service
+      @config_resolver = EzConfig::ConfigResolver.new(client)
+      boot_resolver(@config_service)
     end
 
-    def self.value_to_delta(key, config_value, namespace = nil)
-      PrefabProto::Config.new(key: [namespace, key].compact.join(':'),
-                              rows: [PrefabProto::ConfigRow.new(value: config_value)])
+    def get(prop)
+      @config_resolver.get(prop)
     end
 
-    def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
-      context = @config_resolver.make_context(properties)
-
-      if !context.blank? && @base_client.example_contexts_aggregator
-        @base_client.example_contexts_aggregator.record(context)
-      end
-
-      evaluation = _get(key, context)
-
-      @base_client.context_shape_aggregator&.push(context)
-
-      if evaluation
-        evaluation.report_and_return(@base_client.evaluation_summary_aggregator)
-      else
-        handle_default(key, default)
-      end
+    def set(config_value)
+      @config_service.upsert(config_value)
     end
 
     private
 
-    def raw(key)
-      @config_resolver.raw(key)
-    end
-
-    def handle_default(key, default)
-      return default if default != NO_DEFAULT_PROVIDED
-
-      raise Prefab::Errors::MissingDefaultError, key if @options.on_no_default == Prefab::Options::ON_NO_DEFAULT::RAISE
-
-      nil
-    end
-
-    def _get(key, properties)
-      # wait timeout sec for the initialization to be complete
-      @initialized_future.value(@options.initialization_timeout_sec)
-      if @initialized_future.incomplete?
-        unless @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
-          raise Prefab::Errors::InitializationTimeoutError.new(@options.initialization_timeout_sec, key)
-        end
-
-        LOG.warn("Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have")
-        @initialization_lock.release_write_lock
-      end
-
-      @config_resolver.get key, properties
-    end
-
-    def load_checkpoint
-      success = load_checkpoint_api_cdn
-
-      return if success
-
-      success = load_checkpoint_api
-
-      return if success
-
-      success = load_cache
-
-      return if success
-
-      LOG.warn 'No success loading checkpoints'
-    end
-
-    def load_checkpoint_api_cdn
-      conn = Prefab::HttpConnection.new("#{@options.url_for_api_cdn}/api/v1/configs/0", @base_client.api_key)
-      load_url(conn, :remote_cdn_api)
-    end
-
-    def load_checkpoint_api
-      conn = Prefab::HttpConnection.new("#{@options.prefab_api_url}/api/v1/configs/0", @base_client.api_key)
-      load_url(conn, :remote_api)
-    end
-
-    def load_url(conn, source)
-      resp = conn.get('')
-      if resp.status == 200
-        configs = PrefabProto::Configs.decode(resp.body)
-        load_configs(configs, source)
-        cache_configs(configs)
-        true
-      else
-        LOG.info "Checkpoint #{source} failed to load. Response #{resp.status}"
-        false
-      end
-    rescue Faraday::ConnectionFailed => e
-      if @initialization_lock.write_locked?
-        LOG.warn "Connection Fail loading #{source} checkpoint."
-      else
-        LOG.debug "Connection Fail loading #{source} checkpoint."
-      end
-      false
-    rescue StandardError => e
-      LOG.warn "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
-      LOG.debug e.backtrace
-      false
-    end
-
-    def load_configs(configs, source)
-      project_id = configs.config_service_pointer.project_id
-      project_env_id = configs.config_service_pointer.project_env_id
-      @config_resolver.project_env_id = project_env_id
-      starting_highwater_mark = @config_loader.highwater_mark
-
-      default_contexts = configs.default_context&.contexts&.map do |context|
-        [
-          context.type,
-          context.values.keys.map do |k|
-            [k, Prefab::ConfigValueUnwrapper.new(context.values[k], @config_resolver).unwrap]
-          end.to_h
-        ]
-      end.to_h
-
-      @config_resolver.default_context = default_contexts || {}
-
-      configs.configs.each do |config|
-        @config_loader.set(config, source)
-      end
-      if @config_loader.highwater_mark > starting_highwater_mark
-        LOG.debug("Found new checkpoint with highwater id #{@config_loader.highwater_mark} from #{source} in project #{project_id} environment: #{project_env_id} and namespace: '#{@namespace}'")
-      else
-        LOG.debug("Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.")
-      end
-      @config_resolver.update
-      finish_init!(source, project_id)
-    end
-
-    def cache_path
-      return @cache_path unless @cache_path.nil?
-      @cache_path ||= calc_cache_path
-      FileUtils.mkdir_p(File.dirname(@cache_path))
-      @cache_path
-    end
-
-    def calc_cache_path
-      file_name = "prefab.cache.#{@base_client.options.api_key_id}.json"
-      dir = ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache'))
-      File.join(dir, file_name)
-    end
-
-    def cache_configs(configs)
-      return unless @options.use_local_cache && !@options.is_fork
-      File.open(cache_path, "w") do |f|
-        f.flock(File::LOCK_EX)
-        f.write(PrefabProto::Configs.encode_json(configs))
-      end
-      LOG.debug "Cached configs to #{cache_path}"
-    rescue => e
-      LOG.debug "Failed to cache configs to #{cache_path} #{e}"
-    end
-
-    def load_cache
-      return false unless @options.use_local_cache
-      File.open(cache_path) do |f|
-        f.flock(File::LOCK_SH)
-        configs = PrefabProto::Configs.decode_json(f.read)
-        load_configs(configs, :cache)
-
-        hours_old = ((Time.now - File.mtime(f)) / 60 / 60).round(2)
-        if hours_old > STALE_CACHE_WARN_HOURS
-          LOG.info "Stale Cache Load: #{hours_old} hours old"
-        end
-        true
-      end
-    rescue => e
-      LOG.debug "Failed to read cached configs at #{cache_path}. #{e}"
-      false
-    end
-
-    def load_json_file(file)
-      File.open(file) do |f|
-        f.flock(File::LOCK_SH)
-        configs = PrefabProto::Configs.decode_json(f.read)
-        load_configs(configs, :datafile)
-      end
-    end
+    def boot_resolver(config_service)
+      config_req = Prefab::ConfigServicePointer.new(account_id: 1,
+                                                    start_at_id: 0)
 
-    # A thread that checks for a checkpoint
-    def start_checkpointing_thread
       Thread.new do
-        loop do
-          started_at = Time.now
-          delta = @checkpoint_freq_secs - (Time.now - started_at)
-          sleep(delta) if delta > 0
-
-          load_checkpoint
-        rescue StandardError => e
-          LOG.debug "Issue Checkpointing #{e.message}"
-        end
-      end
-    end
-
-    def finish_init!(source, project_id)
-      return unless @initialization_lock.write_locked?
-
-      LOG.debug "Unlocked Config via #{source}"
-      @initialization_lock.release_write_lock
-
-      Prefab::LoggerClient.instance.config_client = self
-      presenter = Prefab::ConfigClientPresenter.new(
-        size: @config_resolver.local_store.size,
-        source: source,
-        project_id: project_id,
-        project_env_id: @config_resolver.project_env_id,
-        api_key_id: @base_client.options.api_key_id
-      )
-      LOG.info presenter.to_s
-      LOG.debug to_s
-    end
-
-    def start_sse_streaming_connection_thread(start_at_id)
-      auth = "#{AUTH_USER}:#{@base_client.api_key}"
-      auth_string = Base64.strict_encode64(auth)
-      headers = {
-        'x-prefab-start-at-id' => start_at_id,
-        'Authorization' => "Basic #{auth_string}",
-        'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
-      }
-      url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
-      LOG.debug "SSE Streaming Connect to #{url} start_at #{start_at_id}"
-      @streaming_thread = SSE::Client.new(url,
-                                          headers: headers,
-                                          read_timeout: SSE_READ_TIMEOUT,
-                                          logger: Prefab::SseLogger.new) do |client|
-        client.on_event do |event|
-          configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
-          load_configs(configs, :sse)
+        begin
+          resp = config_service.get_config(config_req)
+          resp.each do |r|
+            r.deltas.each do |delta|
+              @config_resolver.set(delta)
+            end
+            @config_resolver.update
+          end
+        rescue => e
+          @client.logger.warn(e)
         end
       end
     end
   end
 end
+

data/lib/prefab/config_loader.rb

@@ -1,84 +1,51 @@
-# frozen_string_literal: true
-
-module Prefab
+require 'yaml'
+module EzConfig
   class ConfigLoader
-    LOG = Prefab::InternalLogger.new(ConfigLoader)
-
-    attr_reader :highwater_mark
-
-    def initialize(base_client)
-      @base_client = base_client
-      @prefab_options = base_client.options
-      @highwater_mark = 0
-      @classpath_config = load_classpath_config
-      @local_overrides = load_local_overrides
+    def initialize(logger)
+      @logger = logger
+      load_ez_config
+      load_project_config
+      load_local_overrides
       @api_config = Concurrent::Map.new
+      @immutable_config = @ez_config.merge(@project_config)
     end
 
     def calc_config
-      rtn = @classpath_config.clone
+      rtn = @immutable_config.clone
       @api_config.each_key do |k|
         rtn[k] = @api_config[k]
       end
-      rtn.merge(@local_overrides)
+      rtn = rtn.merge(@local_overrides)
+      rtn
     end
 
-    def set(config, source)
-      # don't overwrite newer values
-      return if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
-
-      if config.rows.empty?
-        @api_config.delete(config.key)
-      else
-        if @api_config[config.key]
-          LOG.debug(
-                                    "Replace #{config.key} with value from #{source} #{@api_config[config.key][:config].id} -> #{config.id}")
-        end
-        @api_config[config.key] = { source: source, config: config }
-      end
-      @highwater_mark = [config.id, @highwater_mark].max
+    def set(delta)
+      @api_config[delta.key] = delta.value
     end
 
-    def rm(key)
-      @api_config.delete key
-    end
+    private
 
-    def get_api_deltas
-      configs = PrefabProto::Configs.new
-      @api_config.each_value do |config_value|
-        configs.configs << config_value[:config]
-      end
-      configs
+    def load_ez_config
+      @ez_config = load(".ezconfig.yaml")
     end
 
-    private
-
-    def load_classpath_config
-      return {} if @prefab_options.datafile?
-      classpath_dir = @prefab_options.prefab_config_classpath_dir
-      rtn = load_glob(File.join(classpath_dir, '.prefab.default.config.yaml'))
-      @prefab_options.prefab_envs.each do |env|
-        rtn = rtn.merge load_glob(File.join(classpath_dir, ".prefab.#{env}.config.yaml"))
-      end
-      rtn
+    def load_project_config
+      @project_config = load(".projectconfig.yaml")
     end
 
     def load_local_overrides
-      return {} if @prefab_options.datafile?
-      override_dir = @prefab_options.prefab_config_override_dir
-      rtn = load_glob(File.join(override_dir, '.prefab.default.config.yaml'))
-      @prefab_options.prefab_envs.each do |env|
-        rtn = rtn.merge load_glob(File.join(override_dir, ".prefab.#{env}.config.yaml"))
-      end
-      rtn
+      @local_overrides = load(".ezconfig.overrides.yaml")
     end
 
-    def load_glob(glob)
-      rtn = {}
-      Dir.glob(glob).each do |file|
-        Prefab::YAMLConfigParser.new(file, @base_client).merge(rtn)
+    def load(filename)
+      if File.exist? filename
+
+        YAML.load_file(filename)
+      else
+        @logger.info "No file #{filename}"
+        {}
       end
-      rtn
     end
+
   end
 end

data/lib/prefab/config_resolver.rb

@@ -1,76 +1,63 @@
-# frozen_string_literal: true
-
-module Prefab
+module EzConfig
   class ConfigResolver
-    attr_accessor :project_env_id # this will be set by the config_client when it gets an API response
-    attr_reader :local_store
-
-    attr_accessor :default_context
 
-    def initialize(base_client, config_loader)
+    def initialize(client)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @config_loader = config_loader
-      @project_env_id = 0 # we don't know this yet, it is set from the API results
-      @base_client = base_client
-      @on_update = nil
-      @default_context = {}
+      @namespace = client.namespace
+      @config_loader = EzConfig::ConfigLoader.new(client.logger)
       make_local
     end
 
-    def to_s
-      presenter.to_s
-    end
-
-    def presenter
-      Prefab::ResolvedConfigPresenter.new(self, @lock, @local_store)
-    end
-
-    def raw(key)
-      @local_store.dig(key, :config)
-    end
-
-    def get(key, properties = NO_DEFAULT_PROVIDED)
-      @lock.with_read_lock do
-        raw_config = raw(key)
-
-        return nil unless raw_config
-
-        evaluate(raw_config, properties)
+    def get(property)
+      value = @lock.with_read_lock do
+        @local_store[property][:value]
+      end
+      case value.type
+      when :string then
+        puts "SSString"
+        value.string
+      when :int then
+        puts "INT"
+        value.int
       end
     end
 
-    def evaluate(config, properties = NO_DEFAULT_PROVIDED)
-      Prefab::CriteriaEvaluator.new(config,
-                                    project_env_id: @project_env_id,
-                                    resolver: self,
-                                    namespace: @base_client.options.namespace,
-                                    base_client: @base_client).evaluate(make_context(properties))
+    def set(delta)
+      @config_loader.set(delta)
     end
 
     def update
       make_local
-
-      @on_update ? @on_update.call : nil
-    end
-
-    def on_update(&block)
-      @on_update = block
-    end
-
-    def make_context(properties)
-      if properties == NO_DEFAULT_PROVIDED || properties.nil?
-        Context.current
-      else
-        Context.merge_with_current(properties)
-      end.merge_default(default_context || {})
     end
 
     private
 
     def make_local
+      store = {}
+      @config_loader.calc_config.each do |prop, value|
+        property = prop
+        namespace = ""
+        split = prop.split(":")
+
+        if split.size > 1
+          property = split[1..-1].join
+          namespace = split[0]
+        end
+
+        if (namespace == "") || namespace.start_with?(@namespace)
+          existing = store[property]
+          if existing.nil?
+            store[property] = { namespace: namespace, value: value }
+          elsif existing[:namespace].split(".").size < namespace.split(".").size
+            store[property] = { namespace: namespace, value: value }
+          end
+        end
+
+        puts "prop #{property} namespace #{namespace} value #{value}"
+      end
       @lock.with_write_lock do
-        @local_store = @config_loader.calc_config
+        @local_store = store
       end
     end
   end

data/lib/prefab/noop_cache.rb

@@ -0,0 +1,13 @@
+module Prefab
+  class NoopCache
+    def fetch(name, opts, &method)
+      yield
+    end
+
+    def write(name, value, opts=nil)
+    end
+
+    def read(name)
+    end
+  end
+end

data/lib/prefab/noop_stats.rb

@@ -0,0 +1,8 @@
+module Prefab
+
+  class NoopStats
+    # receives increment("prefab.ratelimit.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
+    def increment(name, opts)
+    end
+  end
+end

data/lib/prefab/prefab_pb.rb

@@ -0,0 +1,39 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: prefab.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/wrappers_pb'
+require 'ratelimit_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "prefab.ConfigServicePointer" do
+    optional :account_id, :int64, 1
+    optional :start_at_id, :int64, 2
+  end
+  add_message "prefab.ConfigDelta" do
+    optional :account_id, :int64, 1
+    optional :id, :int64, 2
+    optional :key, :string, 3
+    optional :value, :message, 4, "prefab.ConfigValue"
+  end
+  add_message "prefab.ConfigValue" do
+    oneof :type do
+      optional :int, :int64, 1
+      optional :string, :string, 2
+      optional :bytes, :bytes, 3
+      optional :double, :double, 4
+      optional :bool, :bool, 5
+      optional :feature_flag, :message, 6, "it.ratelim.data.FeatureFlag"
+    end
+  end
+  add_message "prefab.ConfigDeltas" do
+    repeated :deltas, :message, 1, "prefab.ConfigDelta"
+  end
+end
+
+module Prefab
+  ConfigServicePointer = Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigServicePointer").msgclass
+  ConfigDelta = Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigDelta").msgclass
+  ConfigValue = Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigValue").msgclass
+  ConfigDeltas = Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigDeltas").msgclass
+end

data/lib/prefab/prefab_services_pb.rb

@@ -0,0 +1,37 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: prefab.proto for package 'prefab'
+
+require 'grpc'
+require 'prefab_pb'
+
+module Prefab
+  module RateLimitService
+    class Service
+
+      include GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'prefab.RateLimitService'
+
+      rpc :LimitCheck, It::Ratelim::Data::LimitRequest, It::Ratelim::Data::LimitResponse
+    end
+
+    Stub = Service.rpc_stub_class
+  end
+  module ConfigService
+    class Service
+
+      include GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'prefab.ConfigService'
+
+      rpc :GetConfig, ConfigServicePointer, stream(ConfigDeltas)
+      rpc :Upsert, ConfigDelta, ConfigServicePointer
+    end
+
+    Stub = Service.rpc_stub_class
+  end
+end