sc4ry 0.2.0 → 0.2.1

data/lib/sc4ry/notifiers/init.rb

@@ -1,57 +1,58 @@
-Dir[File.dirname(__FILE__) + '/*.rb'].sort.each { |file| require file unless File.basename(file) == 'init.rb' }
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/*.rb"].sort.each { |file| require file unless File.basename(file) == 'init.rb' }
 
 # Sc4ry module
 # @note namespace
-module Sc4ry 
-
-  # Sc4ry::Notifiers module 
-  # @note namespace 
-    module Notifiers
-
+module Sc4ry
+  # Sc4ry::Notifiers module
+  # @note namespace
+  module Notifiers
     # default notifiers specifications
-    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                           
-  
+    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
+
     # class method how display a specific notifier config
     # @param notifier [Symbol] a notifier name
-    # @return [Hash] the config                     
-    def Notifiers.display_config(notifier: )
-      raise Sc4ry::Exceptions::Sc4ryNotifierError, "Notifier #{notifier} not found" unless @@notifiers_list.include? notifier
-      return @@notifiers_list[notifier][:config]
+    # @return [Hash] the config
+    def self.display_config(notifier:)
+      unless @@notifiers_list.include? notifier
+        raise Sc4ry::Exceptions::Sc4ryNotifierError,
+              "Notifier #{notifier} not found"
+      end
+
+      @@notifiers_list[notifier][:config]
     end
 
     # class method how return the list of known notifiers
     # @return [Array] a list of [Symbol] notifiers name
-    def Notifiers.list
-      return @@notifiers_list.keys
+    def self.list
+      @@notifiers_list.keys
     end
 
     # class method how return a specific notifier by name
     # @param name [Symbol] a notifier name
-    # @return [Hash] the notifier structure                     
-    def Notifiers.get(name: )
-      return @@notifiers_list[name]
+    # @return [Hash] the notifier structure
+    def self.get(name:)
+      @@notifiers_list[name]
     end
 
-    # class method how register a specific notifier 
+    # class method how register a specific notifier
     # @param name [Symbol] a notifier name
-    # @param definition [Hash] a notifier definition 
-    # @return [Hash] the notifier structure                     
-    def Notifiers.register(name: , definition: )
+    # @param definition [Hash] a notifier definition
+    # @return [Hash] the notifier structure
+    def self.register(name:, definition:)
       @@notifiers_list[name] = definition
     end
 
-    
-    # class method how configure a specific notifier 
+    # class method how configure a specific notifier
     # @param name [Symbol] a notifier name
-    # @param config [Hash] a notifier config  
-    # @return [Hash] the notifier structure                     
-    def Notifiers.config(name:, config: )
+    # @param config [Hash] a notifier config
+    # @return [Hash] the notifier structure
+    def self.config(name:, config:)
       @@notifiers_list[name][:config] = config
-      return config
+      config
     end
- end
+  end
 end
-

data/lib/sc4ry/notifiers/mattermost.rb

@@ -1,43 +1,42 @@
+# frozen_string_literal: true
+
 # Sc4ry module
-# @note namespace 
+# @note namespace
 module Sc4ry
-    # Sc4ry::Notifiers module
-    # @note namespace
-    module Notifiers
-        
-        # Mattermost Notifier class
-        class Mattermost
-            
-            # send metrics to Prometheus PushGateway
-            # @return [Bool]
-            def Mattermost.notify(options = {})
-                config = Sc4ry::Notifiers.get(name: :mattermost)[:config]
-                status = options[:config][:status][:general]
-                circuit = options[:circuit]
-                status_map = {:open => 0, :half_open => 1, :closed => 2}
-                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 Notifying : #{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
-                rescue URI::InvalidURIError
-                    Sc4ry::Helpers.log level: :warn, message: "Mattermost Notifier : URL malformed"
-                end
+  # Sc4ry::Notifiers module
+  # @note namespace
+  module Notifiers
+    # Mattermost Notifier class
+    class Mattermost
+      # send metrics to Prometheus PushGateway
+      # @return [Bool]
+      def self.notify(options = {})
+        config = Sc4ry::Notifiers.get(name: :mattermost)[:config]
+        status = options[:config][:status][:general]
+        circuit = options[:circuit]
+        begin
+          uri = URI.parse("#{config[:url]}/hooks/#{config[:token]}")
+          message = "notifying for circuit #{circuit}, state : #{status}."
+          if Sc4ry::Helpers.verify_service url: config[:url]
+            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 Notifying : #{message}"
+            request.body = ::JSON.dump(payload)
+            ::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
+        rescue URI::InvalidURIError
+          Sc4ry::Helpers.log level: :warn, message: 'Mattermost Notifier : URL malformed'
         end
+      end
     end
-end
+  end
+end

data/lib/sc4ry/notifiers/prometheus.rb

@@ -1,43 +1,39 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
-
   # Sc4ry::Notifiers module
   # @note namespace
   module Notifiers
-
-  
     # Prometheus notifier class
     class Prometheus
-
-      @@registry = ::Prometheus::Client::Registry::new
-      @@metric_circuit_state = ::Prometheus::Client::Gauge.new(:cuircuit_state, docstring: 'Sc4ry metric : state of a circuit', labels: [:circuit])
+      @@registry = ::Prometheus::Client::Registry.new
+      @@metric_circuit_state = ::Prometheus::Client::Gauge.new(:cuircuit_state,
+                                                               docstring: 'Sc4ry metric : state of a circuit',
+                                                               labels: [:circuit])
 
       @@registry.register(@@metric_circuit_state)
 
-    
-
       # send metrics to Prometheus PushGateway
       # @return [Bool]
-      def Prometheus.notify(options = {})
+      def self.notify(options = {})
         @config = Sc4ry::Notifiers.get(name: :prometheus)[:config]
         status = options[:config][:status][:general]
         circuit = options[:circuit]
-        status_map = {:open => 0, :half_open => 1, :closed => 2}
-        if Sc4ry::Helpers::verify_service url: @config[:url] then
-          
-          @@metric_circuit_state.set(status_map[status], labels: {circuit: circuit.to_s })
-          Sc4ry::Helpers.log level: :debug, message: "Prometheus Notifier : notifying for circuit #{circuit.to_s}, state : #{status.to_s}."
+        status_map = { open: 0, half_open: 1, closed: 2 }
+        if Sc4ry::Helpers.verify_service url: @config[:url]
+
+          @@metric_circuit_state.set(status_map[status], labels: { circuit: circuit.to_s })
+          Sc4ry::Helpers.log level: :debug,
+                             message: "Prometheus Notifier : notifying for circuit #{circuit}, state : #{status}."
 
-          return ::Prometheus::Client::Push.new(job: "Sc4ry", instance: Socket.gethostname, gateway: @config[:url]).add(@@registry)
+          ::Prometheus::Client::Push.new(job: 'Sc4ry', instance: Socket.gethostname,
+                                         gateway: @config[:url]).add(@@registry)
         else
           Sc4ry::Helpers.log level: :warn, message: "Prometheus Notifier : can't notify Push Gateway not reachable."
         end
       end
     end
-
-    
-    
   end
-
 end

data/lib/sc4ry/run_controller.rb

@@ -1,16 +1,15 @@
+# frozen_string_literal: true
 
 # Sc4ry module
-# @note namespace 
+# @note namespace
 module Sc4ry
-
   # class Facility to run and update values/status for a circuit Proc
   class RunController
-
     # return the execution time of the proc
     attr_reader :execution_time
 
     # constructor
-    # @param [Hash] circuit the data of the circuit 
+    # @param [Hash] circuit the data of the circuit
     def initialize(circuit = {})
       @circuit = circuit
       @execution_time = 0
@@ -22,59 +21,53 @@ module Sc4ry
     # return if the Proc failed on a covered exception by this circuit
     # @return [Boolean]
     def failed?
-      return @failure
-    end 
+      @failure
+    end
 
     # return if the Proc overtime the specified time of the circuit
     # @return [Boolean]
-    def overtimed? 
-      return @overtime
+    def overtimed?
+      @overtime
     end
 
     # return if the Proc timeout the timeout defined value of the circuit, if timeout is active
     # @return [Boolean]
-    def timeout? 
-      return @timeout
+    def timeout?
+      @timeout
     end
 
     # run and update values for the bloc given by keyword
     # @param [Proc] block a block to run and calculate
     # @return [Hash] a result Hash
-    def run(block: )
+    def run(block:)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      begin 
+      begin
         if @circuit[:timeout] == true
-          Timeout::timeout(@circuit[:timeout_value]) do 
+          Timeout.timeout(@circuit[:timeout_value]) do
             block.call
           end
           @timeout = false
         else
           block.call
         end
-      rescue Exception => e
+      rescue StandardError => e
         @last_exception = e.class.to_s
-        if e.class  == Timeout::Error then 
+        if e.instance_of?(Timeout::Error)
           @timeout = true
         elsif @circuit[:exceptions].include? e.class
           @failure = true
-        else  
-          if @circuit[:forward_unknown_exceptions] then
+        elsif @circuit[:forward_unknown_exceptions]
+          raise e.class, "Sc4ry forward: #{e.message}"
+        else
+          Sc4ry::Helpers.log level: :debug, message: "skipped : #{@last_exception}"
 
-            raise e.class, "Sc4ry forward: #{e.message}" 
-          else
-            Sc4ry::Helpers.log level: :debug, message: "skipped : #{@last_exception}"
-          end
-          
-        end 
+        end
       end
       @end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @execution_time = @end_time - start_time
-      @overtime = @execution_time > @circuit[:max_time] 
-      return {failure: @failure, overtime: @overtime, timeout: @timeout, execution_time: @execution_time, end_time: @end_time, last_exception: @last_exception}
-
+      @overtime = @execution_time > @circuit[:max_time]
+      { failure: @failure, overtime: @overtime, timeout: @timeout, execution_time: @execution_time,
+        end_time: @end_time, last_exception: @last_exception }
     end
-
-
-
   end
-end
+end

data/lib/sc4ry/store.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
-
-# Sc4ry::Store class
-# Store Class Provider/manager singleton Forwarder on {Sc4ry::Backends::Memory} or {Sc4ry::Backends::Redis}
-# @note must be accessed by {Sc4ry::Circuits.store}
+  # Sc4ry::Store class
+  # Store Class Provider/manager singleton Forwarder on {Sc4ry::Backends::Memory} or {Sc4ry::Backends::Redis}
+  # @note must be accessed by {Sc4ry::Circuits.store}
   class Store
-
     @@current = :memory
 
     extend Forwardable
     include Singleton
 
-    @@backends = {:memory => {:class => Sc4ry::Backends::Memory, config: {}},
-                  :redis  => {:class => Sc4ry::Backends::Redis, :config => {:host => 'localhost', :port => 6379, :db => 10 }}}
+    @@backends = { memory: { class: Sc4ry::Backends::Memory, config: {} },
+                   redis: { class: Sc4ry::Backends::Redis, config: { host: 'localhost', port: 6379, db: 1 } } }
 
     # accessor on current backend (default :memory)
     attr_reader :be
-    
+
     def_delegators :@be, :put, :get, :flush, :exist?, :del, :list
 
     # constructor pointing on :memory backend
     def initialize
-      change_backend name: @@current 
-    end 
+      change_backend name: @@current
+    end
 
     # return the current backend
     # @return [Object] in {Sc4ry::Backends::Memory} or {Sc4ry::Backends::Redis}
@@ -31,75 +31,81 @@ module Sc4ry
     #    include Sc4ry
     #    puts Circuits.store.current
     def current
-      return @@current
+      @@current
     end
 
     # return  the config of a specific backend
-    # @param [Symbol] backend the name the backend 
-    # @return [Hash] the config of the backend 
+    # @param [Symbol] backend the name the backend
+    # @return [Hash] the config of the backend
     # @raise  Sc4ry::Exceptions::Sc4ryBackendError if backend is not found
     # @example usage
     #    include Sc4ry
     #    puts Circuits.store.get_config backend: :redis
-    def get_config(backend: )
+    def get_config(backend:)
       raise Sc4ry::Exceptions::Sc4ryBackendError, "backend #{backend} not found" unless @@backends.include? backend
-      return @@backends[backend][:config]
+
+      @@backends[backend][:config]
     end
 
-    # list backend available  
+    # list backend available
     # @return [Array] of Symbol the list of backend name
     # @example usage
     #    include Sc4ry
     #    puts Circuits.store.list_backend
     def list_backend
-      return @@backends.keys
+      @@backends.keys
     end
 
-    # change the current backend 
-    # @note if changing form :memory to :redis => all values and result are lost and circuits will be lost 
-    # @note if changing to :redis, get all the define circuits with values and status (ideal) for distributed worker/instance/runner/services
+    # change the current backend
+    # @note if changing form :memory to :redis => all values and result are lost and circuits will be lost
+    # @note if changing to :redis, get all the define circuits with values and status (ideal)
+    # @note for distributed worker/instance/runner/services
     # @param [Symbol] name the name of the target backend
     # @return [Symbol] the name of the new current backend
     # @raise Sc4ry::Exceptions::Sc4ryBackendError if backend is not found
-    def change_backend(name: )
+    def change_backend(name:)
       raise Sc4ry::Exceptions::Sc4ryBackendError, "backend #{name} not found" unless @@backends.include? name
+
       @@current =  name
-      @be = @@backends[@@current][:class]::new(@@backends[@@current][:config])
-      return name
+      @be = @@backends[@@current][:class].new(@@backends[@@current][:config])
+      name
     end
 
-    # register a new backend 
+    # register a new backend
     # @param [Symbol] name the name of the backend
     # @param [Hash] config the config for this backend
-    # @param [Class] backend_class the class name of the new backend 
+    # @param [Class] backend_class the class name of the new backend
     # @raise Sc4ry::Exceptions::Sc4ryBackendError if backend already exist
-    # @return [Symbol] the name of the backend  
-    def register_backend(name:, config: {}, backend_class:)
-      raise Sc4ry::Exceptions::Sc4ryBackendError , "backend #{name} already exist" if @@backends.include? name
-      @@backends[name] = {config: config, class: backend_class}
-      return name
+    # @return [Symbol] the name of the backend
+    def register_backend(name:, backend_class:, config: {})
+      raise Sc4ry::Exceptions::Sc4ryBackendError, "backend #{name} already exist" if @@backends.include? name
+
+      @@backends[name] = { config: config, class: backend_class }
+      name
     end
 
     # delete the specified backend reference
     # @param [Symbol] name the name of the target backend
     # @raise Sc4ry::Exceptions::Sc4ryBackendError if backend is not found, or name == :memory or :redis
     # @return [Boolean]
-    def delete_backend(name: )
-      raise Sc4ry::Exceptions::Sc4ryBackendError , "Delete forbidden for backend in [:redis,:memory]" if [:memory,:redis].include? name
-      raise Sc4ry::Exceptions::Sc4ryBackendError , "backend #{name} not found" unless @@backends.include? name
-      return @@backends.delete(name)
+    def delete_backend(name:)
+      forbidden_mes = 'Delete forbidden for backend in [:redis,:memory]'
+      notfound_mes = "backend #{name} not found"
+      raise Sc4ry::Exceptions::Sc4ryBackendError, forbidden_mes if %i[memory redis].include? name
+      raise Sc4ry::Exceptions::Sc4ryBackendError, notfound_mes  unless @@backends.include? name
+
+      @@backends.delete(name)
     end
- 
+
     # change the specified backend config
     # @param [Symbol] name the name of the target backend
     # @param [Hash] config the config of the specified backend
     # @raise Sc4ry::Exceptions::Sc4ryBackendError if backend is not found, or name == :memory
     def config_backend(name:, config:)
       raise Sc4ry::Exceptions::Sc4ryBackendError, "backend #{name} not found" unless @@backends.include? name
-      raise Sc4ry::Exceptions::Sc4ryBackendError, "backend :memory not need config" if name == :memory
+      raise Sc4ry::Exceptions::Sc4ryBackendError, 'backend :memory not need config' if name == :memory
+
       @@backends[name][:config] = config
     end
-
-
   end
-end
+end

data/lib/sc4ry/version.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'version'
 
 # Sc4ry module
 # @note namespace
 module Sc4ry
-
   # the version of Sc4ry
   VERSION = Version.current
 end

data/lib/sc4ry.rb

@@ -1,10 +1,4 @@
-require "sc4ry/version"
-require "sc4ry/dependencies"
-
-
-
-
-
-
-
+# frozen_string_literal: true
 
+require 'sc4ry/version'
+require 'sc4ry/dependencies'

data/samples/test.rb

@@ -0,0 +1,159 @@
+require 'rubygems'
+require 'sc4ry'
+
+include Sc4ry
+
+# display of default Sc4ry config
+puts '1.1/ CONFIG : Initial default config'
+Circuits.default_config.each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+# testing the two ways to configure Sc4ry default config
+puts '1.2/ CONFIG : modifying default config activate timout and set max_time to 12'
+Circuits.merge_default_config diff: { timeout: true }
+Circuits.configure do |spec|
+  spec.max_time = 12
+end
+puts ''
+
+# display default config, must be override with a nested hash by calling default_config= method
+puts '1.3/ CONFIG : Default config updated:'
+Circuits.default_config.each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+# display current data Store
+print '2.1/ STORE : Current datastore backend : '
+puts Circuits.store.current
+puts ''
+
+# display available backend
+puts '2.2/ STORE : List of existing backends : '
+Circuits.store.list_backend.each do |backend|
+  puts " - #{backend}"
+end
+puts ''
+
+# display Redis backend config in store before change
+puts '2.3/ STORE : display default config of redis backend'
+Circuits.store.get_config(backend: :redis).each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+# reconfigure a backend
+puts '2.4/ STORE : reconfigure Redis backend'
+Circuits.store.config_backend name: :redis, config: { host: 'localhost', port: 6379, db: 10 }
+puts
+
+# display after
+puts '2.5/ STORE : display altered config of redis backend'
+Circuits.store.get_config(backend: :redis).each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+# change backend
+
+puts '2.6/ STORE : change to redis backend (NEED a Redis installed) '
+puts '  $ docker pull redis:latest'
+puts '  $ docker run --rm -d  -p 6379:6379/tcp redis:latest'
+Circuits.store.change_backend name: :redis
+puts ''
+
+puts '2.7/ STORE : flush redis backend, just for test, and for idempotency (NEED a Redis installed) '
+Circuits.store.flush
+puts ''
+
+# defining a circuit, config must be empty or override from default
+puts '3.1/ CIRCUIT : registering a circuit by merge :'
+Circuits.register circuit: :test, config: { notifiers: %i[prometheus mattermost], exceptions: [Errno::ECONNREFUSED, URI::InvalidURIError] }
+puts ''
+
+puts '3.2/ CIRCUIT : registering a circuit by block :'
+Circuits.register circuit: :test2 do |spec|
+  spec.exceptions = [Errno::ECONNREFUSED]
+end
+puts ''
+
+puts '3.3/ CIRCUIT : registering a circuit by default :'
+Circuits.register circuit: :test3
+puts ''
+
+puts '3.4/ CIRCUITS : Circuits list'
+Circuits.list.each do |circuit|
+  puts " * #{circuit}"
+end
+puts ''
+
+puts '3.5/ CIRCUIT : display a circuit config :test3 :'
+Circuits.get(circuit: :test3).each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+puts '3.6/ CIRCUIT : update config of :test3 => :raise_on_opening == true  :'
+Circuits.update_config circuit: :test3, config: { raise_on_opening: true }
+puts ''
+
+puts '3.7/ CIRCUIT : display a circuit config :test3 after change :'
+Circuits.get(circuit: :test3).each do |item, value|
+  puts " * #{item} : #{value}"
+end
+puts ''
+
+puts '3.8/ unregister a circuit : :test2 :'
+Circuits.unregister circuit: :test2
+puts ''
+
+puts '3.9/ CIRCUITS : Circuits list after unregister'
+Circuits.list.each do |circuit|
+  puts " * #{circuit}"
+end
+puts ''
+
+# Config an alternate logger
+
+puts '4.1/ LOGGER : register a logger on file '
+Circuits.loggers.register name: :perso, instance: ::Logger.new('/tmp/logfile.log')
+puts ''
+
+puts '4.2/ LOGGER : get the list of available loggers'
+Circuits.loggers.list_available.each do |logger|
+  puts " * #{logger}"
+end
+puts ''
+
+puts '4.3/ LOGGER : change logger to :perso'
+Circuits.loggers.current = :perso
+puts ''
+
+# sample Mattermost notification
+puts '5/ set notifier mattermost on dummy url, change with your slack or mattermost server'
+Sc4ry::Notifiers.config name: :mattermost, config: { url: 'https://mattermost.mycorp.com', token: '<TOKEN>' }
+puts ''
+
+# sample loop
+puts '6/ running circuits test, please wait ... (see /tmp/logfile.log for result)'
+puts ' check endoint status for different result, you cloud use http://github.com/Ultragreen/MockWS for testing endpoint, on an other tty'
+puts '  $ git clone https://github.com/Ultragreen/MockWS.git'
+puts '  $ cd MockWS'
+puts '  $ rackup'
+begin
+  10.times do
+    sleep 1
+    Circuits.run circuit: :test do
+      # for the test choose or build an endpoint you must shutdown
+      puts RestClient.get('http://localhost:9292/test2/data')
+    end
+  end
+rescue Interrupt
+  puts 'Interrputed'
+ensure
+  Circuits.store.flush
+end
+
+puts 'end'