sc4ry 0.1.5 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9a3fb1c8109f854824988f024f067a17a4911af9a50a6fe2b3810b48ee04a3e
-  data.tar.gz: b76605ccc355dcba888eae092ed01fd554a1d74de80bbc576e5942ff1f8e6d41
+  metadata.gz: 19791a7d72756fe96464fd43fd648010a71ff7491b96702da23c8828c19f58a2
+  data.tar.gz: 6e1d7318a3de28fd0950213f9e8bf344819dc5858f66f5ce0ec5b1eb7275b99f
 SHA512:
-  metadata.gz: 466cbe185262a5b854b70812ce7d37f8e2032fb3f85346f3d3c42dfe202757dcc1f1b7634b91327d73bb8e795c11093c75867de002011b0e6832c28221396eea
-  data.tar.gz: f93131f1c494030d16377fec8fb8380755265a44a497365e8246e9e9a80c43cd3d921ac2b327cf17e74df6c665541a9a1c610a6916b20d9f3ae2b30391760a08
+  metadata.gz: 7f2c87ddb8ee4dc04aa1d6b2b9b9f214309fc56749dbb85a648f541ca1c27621dffdfcb9619348c3cd57874f5f9e9f0c24371fc9926150d32bb62edf3d5e4798
+  data.tar.gz: b43b8a8a6611fa76c890b10ccc40ffbee0f035bf8af298891919dbb9b4bf3ece9fb1ef13fb5386f0807c11e188d6cf7e9448979a4dc3552a62d1043cf53c3a78

data/README.md

@@ -30,39 +30,64 @@ require 'rubygems'
 require 'sc4ry'
 
 
+puts 'Initial default config'
+pp Sc4ry::Circuits.default_config
+
+
+Sc4ry::Circuits.merge_default_config diff: {timeout: true }
+# or with a block
+Sc4ry::Circuits.configure do |spec|
+  spec.max_time = 12
+end
+
+
+# display default config
+puts 'Default config'
+pp Sc4ry::Circuits.default_config
+
+
 # defining a circuit, config must be empty or override from default
-Sc4ry::Circuits.register({:circuit =>:test, :config => {:notifiers => [:prometheus, :mattermost], :exceptions => [Errno::ECONNREFUSED], :timeout =>  true, :timeout_value => 3, :check_delay => 5 }})
+Sc4ry::Circuits.register circuit: :test, config: {:notifiers => [:prometheus,:mattermost], :exceptions => [Errno::ECONNREFUSED, URI::InvalidURIError] }
+# or with a block
+Sc4ry::Circuits.register circuit: :test2 do |spec|
+  spec.exceptions = [Errno::ECONNREFUSED]
+end
+# or 
+Sc4ry::Circuits.register circuit: :test3
 
-# display the list of known circuit
-pp Sc4ry::Circuits.list
 
-# display default config, must be override with a nested hash by calling default_config= method
-pp  Sc4ry::Circuits.default_config
 
+puts "Circuits list"
+pp Sc4ry::Circuits::list
 
-# Config an alternate logger 
+# Config an alternate logger
 Sc4ry::Logger.register name: :perso, instance: ::Logger.new('/tmp/logfile.log')
-Sc4ry::Logger::current = :perso
+Sc4ry::Logger::current = :stdout
 
 
 # default values, circuit is half open before one of the max count is reached
 
-# {:max_failure_count=>5,                      => maximum failure before opening circuit
-#  :timeout_value=>20,                         => timeout value, if :timeout => true
-#  :timeout=>false,                            => (de)activate internal timeout
-#  :max_timeout_count=>5,                      => maximum timeout try before opening circuit
-#  :max_time=>10,                              => maximum time for a circuit run
-#  :max_overtime_count=>3,                     => maximum count of overtime before opening circuit
-#  :check_delay=>30,                           => delay after opening, before trying again to closed circuit or after an other check
-#  :notifiers=>[],                             => active notifier, must be :symbol in [:prometheus, :mattermost]
-#  :forward_unknown_exceptions => true,        => (de)activate forwarding of unknown exceptions, just log in DEBUG if false
-#  :raise_on_opening => false,                 => (de)activate raise specific Sc4ry exceptions ( CircuitBreaked ) if circuit opening
-#  :exceptions=>[StandardError, RuntimeError]} => list of selected Exceptions considered for failure, others are SKIPPED. 
+# DEFAULT_CONFIG = { 
+#             :max_failure_count => 5,
+#             :timeout_value => 20,
+#             :timeout => false,
+#             :max_timeout_count => 5,
+#             :max_time => 10,
+#             :max_overtime_count => 3,
+#             :check_delay => 30,
+#             :notifiers => [],
+#             :forward_unknown_exceptions => true,
+#             :raise_on_opening => false,
+#             :exceptions => [StandardError, RuntimeError]
+#             }
 
 # display configuration for a specific circuit
-pp Sc4ry::Circuits.get circuit: :test
+Sc4ry::Circuits::list.each do |circuit|
+  puts "Config #{circuit} :"
+  pp Sc4ry::Circuits.get circuit: circuit
+end
 
-# sample Mattermost notification
+ # sample Mattermost notification
 #Sc4ry::Notifiers::config({:name => :mattermost, :config =>  {:url => 'https://mattermost.mycorp.com', :token => "<TOKEN>"}})
 
 # sample loop
@@ -70,7 +95,7 @@ pp Sc4ry::Circuits.get circuit: :test
   sleep 1
   Sc4ry::Circuits.run circuit: :test do 
    # for the test choose or build an endpoint you must shutdown  
-   puts RestClient.get('http://<URL_OF_A_ENDPOINT>')
+   puts RestClient.get('http://<URL_OF_AN_ENDPOINT>')
   end
 end
 

data/lib/sc4ry/circuits.rb

@@ -1,31 +1,52 @@
 module Sc4ry
   class Circuits
 
+    include Sc4ry::Constants
+    include Sc4ry::Exceptions
+
     @@circuits_store = Sc4ry::Store.instance 
 
-    @@config = { :max_failure_count => 5,
-                 :timeout_value => 20,
-                 :timeout => false,
-                 :max_timeout_count => 5,
-                 :max_time => 10,
-                 :max_overtime_count => 3,
-                 :check_delay => 30,
-                 :notifiers => [],
-                 :forward_unknown_exceptions => true,
-                 :raise_on_opening => false,
-                 :exceptions => [StandardError, RuntimeError]
-                 }
+    @@config = DEFAULT_CONFIG
 
     def Circuits.default_config
       return @@config
     end
 
-    def Circuits.register(options = {})
-      raise ":circuit is mandatory" unless options[:circuit]
-      name = options[:circuit]
-      override = (options[:config].class == Hash)? options[:config] : {}
-      config = @@config.merge override
-      @@circuits_store.put key: name, value: config 
+    def Circuits.merge_default_config(diff:)
+      validator = Sc4ry::Config::Validator::new(definition: diff, from: @@config)
+      validator.validate!
+      @@config = validator.result 
+
+    end
+
+    def Circuits.configure(&bloc)
+      mapper = Sc4ry::Config::ConfigMapper::new(definition: @@config.dup)
+      yield(mapper)
+      validator = Sc4ry::Config::Validator::new(definition: mapper.config, from: @@config)
+      validator.validate!
+      @@config = validator.result 
+    end
+
+
+    def Circuits.default_config=(config)
+      Sc4ry::Helpers.log level: :warn, message: "DEPRECATED: Circuits.default_config= is deprecated please use Circuits.merge_default_config add: {<config_hash>}"
+      Circuits.merge_default_config(diff: config)
+    end
+
+    def Circuits.register(circuit:, config: {})
+      if config.size > 0 and block_given? then 
+        raise Sc4ryGenericError, "config: keyword must not be defined when block is given"
+      end
+      if block_given? then 
+        mapper = Sc4ry::Config::ConfigMapper::new(definition: @@config.dup)
+        yield(mapper)
+        validator = Sc4ry::Config::Validator::new(definition: mapper.config, from: @@config.dup)
+      else 
+        validator = Sc4ry::Config::Validator::new(definition: config, from: @@config.dup )
+      end
+      validator.validate!
+      Sc4ry::Helpers.log level: :debug, message: "Circuit #{circuit} : registered"
+      @@circuits_store.put key: circuit, value: validator.result 
     end
 
     def Circuits.list
@@ -39,10 +60,10 @@ module Sc4ry
 
     def Circuits.run(options = {}, &block)
       circuits_list = Circuits.list
-      raise "No circuit block given" unless block_given?
-      raise "No circuits defined" if circuits_list.empty? 
+      raise Sc4ryGenericError, "No circuit block given" unless block_given?
+      raise Sc4ryGenericError, "No circuits defined" if circuits_list.empty? 
       circuit_name = (options[:circuit])? options[:circuit] : circuits_list.first
-      raise "Circuit #{circuit_name} not found" unless circuits_list.include? circuit_name
+      raise Sc4ryGenericError, "Circuit #{circuit_name} not found" unless circuits_list.include? circuit_name
       circuit = Circuits.get circuit: circuit_name
       skip = false
       if circuit.include? :status then
@@ -55,7 +76,7 @@ module Sc4ry
         controller = Sc4ry::RunController.new(circuit)
         Circuits.control circuit: circuit_name, values: controller.run(block: block)
       end
-      Sc4ry::Helpers.log level: :info, message: "Circuit #{circuit_name} : status #{circuit[:status]}"
+      Sc4ry::Helpers.log level: :debug, message: "Circuit #{circuit_name} : status #{circuit[:status]}"
 
     end
 
@@ -89,7 +110,9 @@ module Sc4ry
         data[:status][:general] = status if worst_status.include? status
       end
       if save != data[:status][:general] then
-        raise Sc4ry::Exceptions::CircuitBreaked if data[:status][:general] == :open and data[:raise_on_opening]
+        raise CircuitBreaked if data[:status][:general] == :open and data[:raise_on_opening]
+        Sc4ry::Helpers.log level: :error, message: "Circuit #{options[:circuit]} : breacking ! " if data[:status][:general] == :open
+        Sc4ry::Helpers.log level: :info, message: "Circuit #{options[:circuit]} : is now closed" if data[:status][:general] == :closed
         Sc4ry::Helpers.notify circuit: options[:circuit], config: data 
       end          
       @@circuits_store.put key: options[:circuit], value: data

data/lib/sc4ry/config.rb

@@ -0,0 +1,65 @@
+module Sc4ry
+    module Config
+        class Validator
+            attr_reader :definition
+            attr_reader :default
+            
+            def result
+                @default
+            end
+            
+            include Sc4ry::Constants
+            include Sc4ry::Exceptions
+            
+            def initialize(definition: , from: DEFAULT_CONFIG)
+                @default = from
+                @definition = definition
+            end
+            
+            def validate!
+                unknown_keys = @definition.keys.difference @default.keys
+                raise ConfigError::new("Unknown keys in config set : #{unknown_keys.to_s}") unless unknown_keys.empty?
+                validate_formats
+                @default.merge! @definition 
+                format_exceptions
+            end
+            
+            private
+            def validate_formats
+                definition.each do |spec,value|
+                    raise ConfigError::new("#{spec} value #{DEFAULT_CONFIG_FORMATS[spec][:desc]}") unless DEFAULT_CONFIG_FORMATS[spec][:proc].call(value)
+                    if DEFAULT_CONFIG_FORMATS[spec].include? :list then
+                        value.each do |item|
+                            raise ConfigError::new("#{spec} value must be in #{DEFAULT_CONFIG_FORMATS[spec][:list]}") unless DEFAULT_CONFIG_FORMATS[spec][:list].include? item
+                        end
+                    end
+                end
+            end
+            
+            def format_exceptions
+                @default[:exceptions].map! {|item| item = (item.class == String)? Object.const_get(item) : item  }
+            end
+            
+        end
+
+        class ConfigMapper
+
+            include Sc4ry::Constants
+            attr_reader :config
+            
+            def initialize(definition: DEFAULT_CONFIG)
+                @config = definition
+                @config.each do |key,value|
+                    self.define_singleton_method "#{key.to_s}=".to_sym do |val|
+                        key = __method__.to_s.chop.to_sym
+                        @config[key]=val
+                    end
+                    self.define_singleton_method key do 
+                        return @config[__method__]
+                    end
+                end
+            end
+        end
+
+    end
+end

data/lib/sc4ry/constants.rb

@@ -0,0 +1,43 @@
+module Sc4ry
+    module Constants
+
+        CURRENT_NOTIFIERS = [:prometheus, :mattermost]
+        DEFAULT_CONFIG = { 
+            :max_failure_count => 5,
+            :timeout_value => 20,
+            :timeout => false,
+            :max_timeout_count => 5,
+            :max_time => 10,
+            :max_overtime_count => 3,
+            :check_delay => 30,
+            :notifiers => [],
+            :forward_unknown_exceptions => true,
+            :raise_on_opening => false,
+            :exceptions => [StandardError, RuntimeError]
+            }
+
+        DEFAULT_CONFIG_FORMATS = { 
+            :max_failure_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"}, 
+            :timeout_value => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
+            :timeout => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
+            :max_timeout_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
+            :max_time => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
+            :max_overtime_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
+            :check_delay => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
+            :notifiers => {
+                :proc => Proc::new {|item| 
+                  item.class == Array and item.select {|val|  val.class == Symbol }.size == item.size
+                  }, 
+                :desc => "must be an Array of Symbol",
+                :list => CURRENT_NOTIFIERS},
+            :forward_unknown_exceptions => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
+            :raise_on_opening => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
+            :exceptions => {
+                :proc => Proc::new {|item| item.class == Array and item.select {|val|  
+                    [Class,String].include? val.class}.size == item.size
+                }, 
+                :desc => "must be an Array of Exception(Class) or String"}
+            }
+
+    end
+end

data/lib/sc4ry/dependencies.rb

@@ -17,9 +17,13 @@ require 'json'
 require_relative 'helpers'
 require_relative 'exceptions'
 require_relative 'logger'
+require_relative 'constants'
+require_relative 'config'
+require_relative 'notifiers/init'
+require_relative 'exporters/init'
 require_relative 'backends/init'
+
 require_relative 'store'
 require_relative 'run_controller'
 require_relative 'circuits'
-require_relative 'notifiers/init'
-require_relative 'exporters/init'
+

data/lib/sc4ry/exceptions.rb

@@ -7,5 +7,19 @@ module Sc4ry
         
         end
 
+        class Sc4ryGenericError < StandardError
+            def initialize(msg)
+                super(msg)
+              end
+        
+        end
+
+        class ConfigError < StandardError
+            def initialize(msg)
+                super(msg)
+              end
+        
+        end
+
     end
 end

data/lib/sc4ry/notifiers/init.rb

@@ -2,9 +2,12 @@ Dir[File.dirname(__FILE__) + '/*.rb'].sort.each { |file| require file unless Fil
 
 module Sc4ry 
   module Notifiers
-    @@notifiers_list = {:prometheus => {:class => Sc4ry::Notifiers::Prometheus, :config => {:url => 'http://localhost:9091'}},
-                        :mattermost => {:class => Sc4ry::Notifiers::Mattermost, :config => {:url => 'http://localhost:9999', :token => "<CHANGE_ME>"}}                            
-                       }
+
+    DEFAULT_NOTIFIERS = {:prometheus => {:class => Sc4ry::Notifiers::Prometheus, :config => {:url => 'http://localhost:9091'}},
+                          :mattermost => {:class => Sc4ry::Notifiers::Mattermost, :config => {:url => 'http://localhost:9999', :token => "<CHANGE_ME>"}}
+                        }
+    @@notifiers_list =  DEFAULT_NOTIFIERS.dup                           
+  
 
     def Notifiers.list
       return @@notifiers_list.keys

data/lib/sc4ry/notifiers/mattermost.rb

@@ -10,24 +10,27 @@ module Sc4ry
                 status = options[:config][:status][:general]
                 circuit = options[:circuit]
                 status_map = {:open => 0, :half_open => 1, :closed => 2}
-                
-                uri = URI.parse("#{config[:url]}/hooks/#{config[:token]}")
-                message = "notifying for circuit #{circuit.to_s}, state : #{status.to_s}."
-                if Sc4ry::Helpers::verify_service url: config[:url] then
-                    request = ::Net::HTTP::Post.new(uri)
-                    request.content_type = "application/json"
-                    req_options = {
-                        use_ssl: uri.scheme == "https",
-                    }
-                    payload = { "text" => "message : #{message } from #{Socket.gethostname}", "username" => "Sc4ry" }
-                    Sc4ry::Helpers.log level: :debug, message: "Mattermost Notifier : #{message}"
-                    request.body = ::JSON.dump(payload)
-                    response = ::Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-                        http.request(request)
+                begin              
+                    uri = URI.parse("#{config[:url]}/hooks/#{config[:token]}")
+                    message = "notifying for circuit #{circuit.to_s}, state : #{status.to_s}."
+                    if Sc4ry::Helpers::verify_service url: config[:url] then
+                        request = ::Net::HTTP::Post.new(uri)
+                        request.content_type = "application/json"
+                        req_options = {
+                            use_ssl: uri.scheme == "https",
+                        }
+                        payload = { "text" => "message : #{message } from #{Socket.gethostname}", "username" => "Sc4ry" }
+                        Sc4ry::Helpers.log level: :debug, message: "Mattermost Notifier : #{message}"
+                        request.body = ::JSON.dump(payload)
+                        response = ::Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+                            http.request(request)
+                        end
+                        
+                    else
+                        Sc4ry::Helpers.log level: :warn, message: "Mattermost Notifier : can't notify Mattermost not reachable."
                     end
-                    
-                else
-                    Sc4ry::Helpers.log level: :warn, message: "Mattermost Notifier : can't notify Mattermost not reachable."
+                rescue URI::InvalidURIError
+                    Sc4ry::Helpers.log level: :warn, message: "Mattermost Notifier : URL malformed"
                 end
             end
         end

data/lib/sc4ry/version.rb

@@ -1,3 +1,3 @@
 module Sc4ry
-  VERSION = "0.1.5"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sc4ry
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.8
 platform: ruby
 authors:
 - Romain GEORGES
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prometheus-client
@@ -60,6 +60,8 @@ files:
 - lib/sc4ry/backends/memory.rb
 - lib/sc4ry/backends/redis.rb
 - lib/sc4ry/circuits.rb
+- lib/sc4ry/config.rb
+- lib/sc4ry/constants.rb
 - lib/sc4ry/dependencies.rb
 - lib/sc4ry/exceptions.rb
 - lib/sc4ry/exporters/init.rb
@@ -76,7 +78,7 @@ homepage: https://github.com/Ultragreen/sc4ry
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Sc4Ry is Simple Circuitbreaker 4 RubY
 test_files: []