prefab-cloud-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a9979df2d96ea510b54c6b479cba724e0ef1ae7
+  data.tar.gz: 8a73500c4c42dac6f4955b6bd6ff395ddf43511f
+SHA512:
+  metadata.gz: '0937e68bf543c496e25e9dff6ab471b5f73bc626a95899c930251dfa9cc5ccd193414e9b9aa88557dbf7716d93af569d09caf6d7be7f686a64f5a7bc6b2c68f3'
+  data.tar.gz: c92bb4500b4321334be5d288f99baeaba8d19ffd7d1af3b7a7e84d6b6d96e052ca88f91030498558e2af3438a168e434d333d89e2722e2a23f6fcb3637d27e0d

data/.ruby-version

@@ -0,0 +1 @@
+2.4.2

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gem "grpc"
+gem "concurrent-ruby"
+
+group :development do
+  gem "grpc-tools"
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "juwelier", "~> 2.1.0"
+  gem "simplecov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,116 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    docile (1.1.5)
+    faraday (0.12.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.3.0)
+    github_api (0.18.2)
+      addressable (~> 2.4)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8)
+      hashie (~> 3.5, >= 3.5.2)
+      oauth2 (~> 1.0)
+    google-protobuf (3.5.0)
+    googleapis-common-protos-types (1.0.1)
+      google-protobuf (~> 3.0)
+    googleauth (0.6.2)
+      faraday (~> 0.12)
+      jwt (>= 1.4, < 3.0)
+      logging (~> 2.0)
+      memoist (~> 0.12)
+      multi_json (~> 1.11)
+      os (~> 0.9)
+      signet (~> 0.7)
+    grpc (1.7.2)
+      google-protobuf (~> 3.1)
+      googleapis-common-protos-types (~> 1.0.0)
+      googleauth (>= 0.5.1, < 0.7)
+    grpc-tools (1.7.2)
+    hashie (3.5.6)
+    highline (1.7.10)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    json (1.8.6)
+    juwelier (2.1.3)
+      builder
+      bundler (>= 1.13)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+      semver
+    jwt (1.5.6)
+    little-plugger (1.1.4)
+    logging (2.2.2)
+      little-plugger (~> 1.1)
+      multi_json (~> 1.10)
+    memoist (0.16.0)
+    mini_portile2 (2.3.0)
+    minitest (5.10.3)
+    multi_json (1.12.2)
+    multi_xml (0.6.0)
+    multipart-post (2.0.0)
+    nokogiri (1.8.1)
+      mini_portile2 (~> 2.3.0)
+    oauth2 (1.4.0)
+      faraday (>= 0.8, < 0.13)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    os (0.9.6)
+    public_suffix (3.0.1)
+    rack (2.0.3)
+    rake (12.3.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    semver (1.0.1)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.2)
+    shoulda-matchers (2.8.0)
+      activesupport (>= 3.0.0)
+    signet (0.8.1)
+      addressable (~> 2.3)
+      faraday (~> 0.9)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    simplecov (0.15.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  concurrent-ruby
+  grpc
+  grpc-tools
+  juwelier (~> 2.1.0)
+  rdoc (~> 3.12)
+  shoulda
+  simplecov
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Jeff Dwyer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "prefab-cloud-ruby"
+  gem.homepage = "http://github.com/prefab-cloud/prefab-cloud-ruby"
+  gem.license = "MIT"
+  gem.summary = %Q{Prefab Ruby Infrastructure}
+  gem.description = %Q{RateLimits & Config as a service}
+  gem.email = "jdwyer@prefab.cloud"
+  gem.authors = ["Jeff Dwyer"]
+
+  # dependencies defined in Gemfile
+end
+Juwelier::RubygemsDotOrgTasks.new
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "prefab-cloud-ruby #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/prefab/auth_interceptor.rb

@@ -0,0 +1,25 @@
+class AuthInterceptor < GRPC::ClientInterceptor
+  def initialize(api_key)
+    @api_key = api_key
+  end
+
+  def request_response(request:, call:, method:, metadata:)
+    metadata['auth'] = @api_key
+    yield
+  end
+
+  def client_streamer(requests:, call:, method:, metadata:)
+    metadata['auth'] = @api_key
+    yield
+  end
+
+  def server_streamer(request:, call:, method:, metadata:)
+    metadata['auth'] = @api_key
+    yield
+  end
+
+  def bidi_streamer(requests:, call:, method:, metadata:)
+    metadata['auth'] = @api_key
+    yield
+  end
+end

data/lib/prefab/client.rb

@@ -0,0 +1,48 @@
+module Prefab
+  class Client
+
+    attr_reader :account_id, :shared_cache, :stats, :namespace, :logger
+
+    def initialize(api_key:,
+                   ssl_certs: "/usr/local/etc/openssl/cert.pem",
+                   logger: nil,
+                   stats: nil, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
+                   shared_cache: nil, # Something that quacks like Rails.cache ideally memcached
+                   local: false,
+                   namespace: ""
+    )
+      @logger = (logger || Logger.new($stdout)).tap do |log|
+        log.progname = "Prefab" if log.respond_to? :progname=
+      end
+      @stats = (stats || NoopStats.new)
+      @shared_cache = (shared_cache || NoopCache.new)
+      @account_id = api_key.split("|")[0].to_i
+      @namespace = namespace
+
+      @interceptor = AuthInterceptor.new(api_key)
+      @creds = GRPC::Core::ChannelCredentials.new(File.open(ssl_certs).read)
+
+      @channel = GRPC::Core::Channel.new('api.prefab.cloud:8443', nil, @creds)
+      if local
+        @channel = GRPC::Core::Channel.new('localhost:8443', nil, :this_channel_is_insecure)
+      end
+    end
+
+    def config_client
+      @config_client ||= Prefab::ConfigClient.new(Prefab::ConfigService::Stub.new(nil,
+                                                                                  @creds,
+                                                                                  channel_override: @channel,
+                                                                                  interceptors: [@interceptor]),
+                                                  self)
+    end
+
+    def ratelimit_client
+      @ratelimit_client ||= Prefab::RateLimitClient.new(Prefab::RateLimitService::Stub.new(nil,
+                                                                                           @creds,
+                                                                                           channel_override: @channel,
+                                                                                           interceptors: [@interceptor]),
+                                                        self)
+    end
+  end
+end
+

data/lib/prefab/config_client.rb

@@ -0,0 +1,40 @@
+module Prefab
+  class ConfigClient
+    def initialize(config_service, client)
+      @client = client
+      @config_service = config_service
+      @config_resolver = EzConfig::ConfigResolver.new(client)
+      boot_resolver(@config_service)
+    end
+
+    def get(prop)
+      @config_resolver.get(prop)
+    end
+
+    def set(config_value)
+      @config_service.upsert(config_value)
+    end
+
+    private
+
+    def boot_resolver(config_service)
+      config_req = Prefab::ConfigServicePointer.new(account_id: 1,
+                                                    start_at_id: 0)
+
+      Thread.new do
+        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

@@ -0,0 +1,51 @@
+require 'yaml'
+module EzConfig
+  class ConfigLoader
+    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 = @immutable_config.clone
+      @api_config.each_key do |k|
+        rtn[k] = @api_config[k]
+      end
+      rtn = rtn.merge(@local_overrides)
+      rtn
+    end
+
+    def set(delta)
+      @api_config[delta.key] = delta.value
+    end
+
+    private
+
+    def load_ez_config
+      @ez_config = load(".ezconfig.yaml")
+    end
+
+    def load_project_config
+      @project_config = load(".projectconfig.yaml")
+    end
+
+    def load_local_overrides
+      @local_overrides = load(".ezconfig.overrides.yaml")
+    end
+
+    def load(filename)
+      if File.exist? filename
+
+        YAML.load_file(filename)
+      else
+        @logger.info "No file #{filename}"
+        {}
+      end
+    end
+
+  end
+end

data/lib/prefab/config_resolver.rb

@@ -0,0 +1,64 @@
+module EzConfig
+  class ConfigResolver
+
+    def initialize(client)
+      @lock = Concurrent::ReadWriteLock.new
+      @local_store = {}
+      @namespace = client.namespace
+      @config_loader = EzConfig::ConfigLoader.new(client.logger)
+      make_local
+    end
+
+    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 set(delta)
+      @config_loader.set(delta)
+    end
+
+    def update
+      make_local
+    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 = store
+      end
+    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

data/lib/prefab/ratelimit_client.rb

@@ -0,0 +1,58 @@
+module Prefab
+  class RateLimitClient
+    def initialize(ratelimit_service, client)
+      @ratelimit_service = ratelimit_service
+      @client = client
+    end
+
+    def pass?(group)
+      result = acquire([group], 1)
+      return result.passed
+    end
+
+    def acquire(groups, acquire_amount, allow_partial_response: false, on_error: :log_and_pass)
+      expiry_cache_key = "prefab.ratelimit.expiry:#{groups.join(".")}"
+      expiry = @client.shared_cache.read(expiry_cache_key)
+      if !expiry.nil? && Integer(expiry) > Time.now.utc.to_f * 1000
+        @client.stats.increment("prefab.ratelimit.limitcheck.expirycache.hit", tags: [])
+        return It::Ratelim::Data::LimitResponse.new(passed: false, amount: 0)
+      end
+
+      req = It::Ratelim::Data::LimitRequest.new(
+        account_id: @client.account_id,
+        acquire_amount: acquire_amount,
+        groups: groups,
+        allow_partial_response: allow_partial_response
+      )
+
+      result = @ratelimit_service.limit_check(req)
+
+      reset = result.limit_reset_at
+      @client.shared_cache.write(expiry_cache_key, reset) unless reset < 1
+
+      @client.stats.increment("prefab.ratelimit.limitcheck", tags: ["policy_group:#{result.policy_group}", "pass:#{result.passed}"])
+
+      result
+
+    rescue => e
+      handle_error(e, on_error)
+    end
+
+    private
+
+    def handle_error(e, on_error)
+      @client.stats.increment("prefab.ratelimit.error", tags: ["type:limit"])
+      case on_error
+      when :log_and_pass
+        @client.logger.warn(e)
+        It::Ratelim::Data::LimitResponse.new(passed: true, amount: 0)
+      when :log_and_hit
+        @client.logger.warn(e)
+        It::Ratelim::Data::LimitResponse.new(passed: false, amount: 0)
+      when :throw
+        raise e
+      end
+    end
+  end
+end
+

data/lib/prefab/ratelimit_pb.rb

@@ -0,0 +1,125 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: ratelimit.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/wrappers_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "it.ratelim.data.LimitResponse" do
+    optional :passed, :bool, 1
+    optional :expires_at, :int64, 2
+    optional :enforced_group, :string, 3
+    optional :current_bucket, :int64, 4
+    optional :policy_group, :string, 5
+    optional :policy_name, :enum, 6, "it.ratelim.data.LimitResponse.LimitPolicyNames"
+    optional :policy_limit, :int32, 7
+    optional :amount, :int64, 8
+    optional :limit_reset_at, :int64, 9
+    optional :safety_level, :enum, 10, "it.ratelim.data.LimitDefinition.SafetyLevel"
+  end
+  add_enum "it.ratelim.data.LimitResponse.LimitPolicyNames" do
+    value :NOT_SET, 0
+    value :SECONDLY_ROLLING, 1
+    value :MINUTELY_ROLLING, 3
+    value :HOURLY_ROLLING, 5
+    value :DAILY_ROLLING, 7
+    value :MONTHLY_ROLLING, 8
+    value :INFINITE, 9
+    value :YEARLY_ROLLING, 10
+  end
+  add_message "it.ratelim.data.LimitRequest" do
+    optional :account_id, :int64, 1
+    optional :acquire_amount, :int32, 2
+    repeated :groups, :string, 3
+    optional :limit_combiner, :enum, 4, "it.ratelim.data.LimitRequest.LimitCombiner"
+    optional :allow_partial_response, :bool, 5
+  end
+  add_enum "it.ratelim.data.LimitRequest.LimitCombiner" do
+    value :NOT_SET, 0
+    value :MINIMUM, 1
+    value :MAXIMUM, 2
+  end
+  add_message "it.ratelim.data.FeatureFlag" do
+    optional :account_id, :int64, 1
+    optional :feature, :string, 2
+    optional :pct, :double, 3
+    repeated :whitelisted, :string, 4
+    optional :prior_feature_name, :string, 5
+  end
+  add_message "it.ratelim.data.LimitDefinition" do
+    optional :group, :string, 1
+    optional :policy_name, :enum, 2, "it.ratelim.data.LimitResponse.LimitPolicyNames"
+    optional :limit, :int32, 3
+    optional :burst, :int32, 4
+    optional :account_id, :int64, 5
+    optional :last_modified, :int64, 6
+    optional :returnable, :bool, 7
+    optional :safety_level, :enum, 8, "it.ratelim.data.LimitDefinition.SafetyLevel"
+  end
+  add_enum "it.ratelim.data.LimitDefinition.SafetyLevel" do
+    value :NOT_SET, 0
+    value :L4_BEST_EFFORT, 4
+    value :L5_BOMBPROOF, 5
+  end
+  add_message "it.ratelim.data.LimitDefinitions" do
+    repeated :definitions, :message, 1, "it.ratelim.data.LimitDefinition"
+  end
+  add_message "it.ratelim.data.FeatureFlags" do
+    repeated :flags, :message, 1, "it.ratelim.data.FeatureFlag"
+    optional :cache_expiry, :int64, 2
+  end
+  add_message "it.ratelim.data.BucketWrite" do
+    optional :tokenBucket, :message, 1, "it.ratelim.data.TokenBucket"
+    optional :bucket, :string, 2
+  end
+  add_message "it.ratelim.data.TokenBucket" do
+    optional :current_value, :int64, 1
+    optional :time_key, :int64, 2
+    repeated :expiries, :int64, 3
+  end
+  add_message "it.ratelim.data.BufferedRequest" do
+    optional :account_id, :int64, 1
+    optional :method, :string, 2
+    optional :uri, :string, 3
+    optional :body, :string, 4
+    repeated :limit_groups, :string, 5
+    optional :content_type, :string, 6
+    optional :fifo, :bool, 7
+  end
+  add_message "it.ratelim.data.BatchRequest" do
+    optional :account_id, :int64, 1
+    optional :method, :string, 2
+    optional :uri, :string, 3
+    optional :body, :string, 4
+    repeated :limit_groups, :string, 5
+    optional :batch_template, :string, 6
+    optional :batch_separator, :string, 7
+  end
+  add_enum "it.ratelim.data.OnFailure" do
+    value :NOT_SET, 0
+    value :LOG_AND_PASS, 1
+    value :LOG_AND_FAIL, 2
+    value :THROW, 3
+  end
+end
+
+module It
+  module Ratelim
+    module Data
+      LimitResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitResponse").msgclass
+      LimitResponse::LimitPolicyNames = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitResponse.LimitPolicyNames").enummodule
+      LimitRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitRequest").msgclass
+      LimitRequest::LimitCombiner = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitRequest.LimitCombiner").enummodule
+      FeatureFlag = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.FeatureFlag").msgclass
+      LimitDefinition = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitDefinition").msgclass
+      LimitDefinition::SafetyLevel = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitDefinition.SafetyLevel").enummodule
+      LimitDefinitions = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.LimitDefinitions").msgclass
+      FeatureFlags = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.FeatureFlags").msgclass
+      BucketWrite = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.BucketWrite").msgclass
+      TokenBucket = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.TokenBucket").msgclass
+      BufferedRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.BufferedRequest").msgclass
+      BatchRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.BatchRequest").msgclass
+      OnFailure = Google::Protobuf::DescriptorPool.generated_pool.lookup("it.ratelim.data.OnFailure").enummodule
+    end
+  end
+end

data/lib/prefab/store.rb

@@ -0,0 +1,29 @@
+require "concurrent/atomics"
+
+module EzConfig
+  class Store
+    def initialize
+      @store = Concurrent::Map
+      @lock = Concurrent::ReadWriteLock.new
+    end
+
+    def get(key)
+      @lock.with_read_lock do
+        @store[key]
+      end
+    end
+
+    def all
+      @lock.with_read_lock do
+        @store.all
+      end
+    end
+
+    def init(fs)
+      @lock.with_write_lock do
+        @store.replace(fs)
+        @initialized.make_true
+      end
+    end
+  end
+end

data/lib/prefab_client.rb

@@ -0,0 +1,35 @@
+
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development)
+require "concurrent/atomics"
+require 'concurrent'
+require_relative 'prefab/prefab_pb'
+require_relative 'prefab/prefab_services_pb'
+require_relative 'prefab/ratelimit_pb'
+require_relative 'prefab/config_loader'
+require_relative 'prefab/config_resolver'
+require_relative 'prefab/client'
+require_relative 'prefab/ratelimit_client'
+require_relative 'prefab/config_client'
+require_relative 'prefab/auth_interceptor'
+require_relative 'prefab/noop_cache'
+require_relative 'prefab/noop_stats'
+
+
+client = Prefab::Client.new(api_key: ENV["RATELIMIT_API_KEY"], local: false)
+
+start = Time.now
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+puts "pass? #{client.ratelimit_client.pass? "hubtest.secondly"}"
+
+puts "took #{Time.now - start}"
+
+# @@prefab = Prefab::Client.new(api_key: ENV["RATELIMIT_API_KEY"], local: true)
+# @@prefab.rate_limits.check()

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: prefab-cloud-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeff Dwyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: grpc-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RateLimits & Config as a service
+email: jdwyer@prefab.cloud
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+files:
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- Rakefile
+- VERSION
+- lib/prefab/auth_interceptor.rb
+- lib/prefab/client.rb
+- lib/prefab/config_client.rb
+- lib/prefab/config_loader.rb
+- lib/prefab/config_resolver.rb
+- lib/prefab/noop_cache.rb
+- lib/prefab/noop_stats.rb
+- lib/prefab/prefab_pb.rb
+- lib/prefab/prefab_services_pb.rb
+- lib/prefab/ratelimit_client.rb
+- lib/prefab/ratelimit_pb.rb
+- lib/prefab/store.rb
+- lib/prefab_client.rb
+homepage: http://github.com/prefab-cloud/prefab-cloud-ruby
+licenses:
+- MIT
+metadata: {}
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Prefab Ruby Infrastructure
+test_files: []