carioca 0.1 → 1.0

data/lib/carioca_private.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+#---
+# Author : Romain GEORGES
+# type : gem component library
+# obj : Carioca Private Module (mixin for Carioca::Services::Registry)
+#---
+
+# private methods to mixin  Carioca::Services::Registry
+# @private
+module PrivateMethodsCariocaServicesRegistry
+
+
+  # private initializer
+  def initialize(_options)
+    @logger_not_in_reg = false
+    @debug = _options[:debug]
+    @registry_filename = _options[:file]
+    @list  = Hash::new
+    load if File::exist?(@registry_filename)
+    unless @list.include?('logger') then
+      self.register_service({:name => 'logger', 
+                              :service => 'Carioca::Services::InternalLogger',
+                              :resource => 'logger', 
+                              :description => "The standard ruby Logger internal wrapper Service", 
+                              :type => :builtin, 
+                              :init_options => { :target => "/tmp/log.file"}})
+      @logger_not_in_reg = true
+    end         
+    @loaded_services = Hash::new
+    # preload logger service
+    @log = self.start_service :name => 'logger' 
+    @log.level =(@debug)? Logger::DEBUG : Logger::INFO     
+    @log.debug('Carioca') { "Registry started, service logger preloaded" }
+    @log.debug('Carioca') { "Logger registered, not in configured registry" } if @logger_not_in_reg
+  end
+  
+  # verify dependancies in services structure 
+  # in @list from a service defition 
+  # in _options and start it if needed
+  def verify_requires_dependancies(_options)
+    _name = _options[:shortname]
+    if @list[_name].include?(:requires) then
+      @list[_name][:requires].each do |service|
+        raise RegistryError::new 'Missing Required depedancy #{service}' unless @list.keys.include? service
+        unless @loaded_services.include?(service) then
+          @log.debug('Carioca') { "Registry dependancy found and not loaded : #{service}" }
+          restart_service :name => service 
+        end
+      end
+    end      
+  end
+  
+  # require file for a service 
+  # from a service definition in _options
+  def require_service(_options)
+    _name = _options[:shortname]
+    sym = ":#{@list[_name][:service].split('::').last}"
+    case @list[_name][:type] 
+    when :file then
+      require @list[_name][:resource]
+    when :builtin then
+      _file = Carioca::Services::search_builtins _name
+      if _file then
+        require _file
+      else
+        raise RegistryError::new("Config failed")
+      end
+    when :gem then
+      eval("require '#{@list[_name][:resource]}'") 
+    else 
+      raise RegistryError::new("Config failed")
+    end
+  end
+
+  # instanciate Object from class defintion of a service defined in 
+  # the service definition in _options
+  def instanciate_service(_options)
+
+    _name = _options[:shortname]
+    @list[_name][:init_options].merge! _options[:params] unless _options[:params].nil?
+    if @list[_name][:init_options].nil? then 
+      eval("@loaded_services[_options[:name]] = #{@list[_name][:service]}::new")
+    else
+      eval("@loaded_services[_options[:name]] = #{@list[_name][:service]}::new(@list[_name][:init_options])")
+    end
+    @log.debug('Carioca') { "Service #{_options[:name]} started" } if @log
+    return @loaded_services[_options[:name]]
+  end
+  
+  # call the garbage method of a service if exist and 
+  # Delete from the loaded services list
+  def kill_service(_name)
+    @loaded_services[_name].garbage if @loaded_services[_name].respond_to? :garbage
+    @loaded_services.delete(_name)
+  end
+
+
+end # end of PrivateMethodsCariocaServicesRegistry
+
+

data/lib/services.rb

@@ -1,5 +1,20 @@
+#!/usr/bin/env ruby
+#---
+# Author : Romain GEORGES
+# type : gem component library
+# obj : Carioca::Services Module
+#---
+
+
+
 module Carioca
+
+  # namespace Services for Registry AND buitlins
   module  Services
+    # class method returning full path in Carioca gem for builtin services files according to installed gem path. 
+    # @note do not use directly for generale purpose (expert/hacks only)
+    # @param [String] _name the name of a service
+    # @return [String,false] the full path filename orfalse if not found
     def Services::search_builtins(_name)
       asearch = Gem.searcher
       spec = asearch.find('carioca')
@@ -17,10 +32,51 @@ module Carioca
         return false
       end
     end
+    
+    # class method returning the [Carioca::Services::Registry]@list complement for builtins service found for a carioca gem version
+    # @note do not use directly for generale purpose (expert/hacks only)
+    # @return [Hash] the [Carioca::Services::Registry]@list complement
+    def Services::discover_builtins
 
-    def Services::discover_builtin
-    end
+      asearch = Gem.searcher
+      spec = asearch.find('carioca')
+      if spec then
+        res = asearch.lib_dirs_for(spec).split('/')
+        res.pop
+        services_path = res.join('/').concat('/lib/services')
+      else
+        services_path = "lib/services"
+      end
+
+      map = Dir["#{services_path}/*"]
+      map.delete_if { |item| not File::file?(item) }
+      map.delete_if { |item| File::basename(item) == 'logger.rb' }
 
+      res = {}
+      map.each do |file|
+        Services::validate_service(file,res)
+      end
+      return res
+    end
 
+    def Services::validate_service(file,res)
+        init_options =  {}
+        if open(file).grep(/^# \$BUILTIN/).size > 0 then
+          service = open(file).grep(/# \$SERVICE/).first.split[2] 
+          resource = open(file).grep(/# \$RESOURCE/).first.split[2]
+          desc = open(file).grep(/# \$DESCRIPTION/).first
+          desc = desc.split(' ')
+          desc.shift(2)
+          description= desc.join(' ')
+          open(file).grep(/# \$INIT_OPTIONS/).each do |opt|
+            prev = opt.split
+            init_options[prev[2].to_sym] = prev[4]
+          end
+        end
+        unless service.nil? or resource.nil? or description.nil? then
+          res[resource] = { :service => service, :type => :builtin, :description => description, :resource => resource}
+          res[resource][:init_options] = init_options unless init_options.empty?
+        end
+    end    
   end
 end

data/lib/services/configuration.rb

@@ -1,4 +1,11 @@
 #!/usr/bin/env ruby
+# $BUILTIN
+# $NAME configuration
+# $SERVICE Carioca::Services::Configuration 
+# $RESOURCE configuration
+# $DESCRIPTION The Carioca Configuration Service
+# $INIT_OPTIONS config_file => ./.config
+
 # Copyright Ultragreen (c) 2005
 #---
 # Author : Romain GEORGES 
@@ -11,41 +18,166 @@
 require 'rubygems'
 require 'methodic'
 require 'services'
+require 'yaml'
+
+# overwriting Hash class 
+# @private
+class Hash
+
+  
+  # recursively transform Hash keys form String to Symbols 
+  # come from Rails code
+  # exist in Ruby 2.0
+  def deep_symbolize
+    target = dup
+    target.inject({}) do |memo, (key, value)|
+      value = value.deep_symbolize if value.is_a?(Hash)
+      memo[key.to_sym] = value
+      memo
+    end
+  end
+
+  # pretty accessor for hash record
+  # like ahash[:key] => ahash.key
+  # r/w accessor 
+  def method_missing(name, *args, &block)
+    if name.to_s =~ /(.+)=$/
+      self[$1.to_sym] = args.first
+    else
+      self[name.to_sym]
+    end
+  end
+end
+    
+
+
+
 
 module Carioca
+
   module Services 
-    
-    class Configuration
+
+    # settings Hash record utilities class
+    # @note please do not use Standalone ( dependancy of Configuration class )
+    # @private
+    class Settings < Hash
+      
+      # the name of the config file in YAML format
+      attr_accessor :config_file
+      
+      # constructor  (pre-open the config file in YAML)
+      # @param [Hash] options the options records
+      # @option options [String] :config_file (REQUIRED) the name of the config file
+      # @option options [String] :context a context (root) name to bind in YAML Structure
+      def initialize(options = {})
+        @config_file = options[:config_file]
+        newsets = {}
+        if File::exist?(@config_file) then
+          newsets = YAML::load_file(@config_file).deep_symbolize
+          newsets = newsets[options[:context].to_sym] if options[:context] && newsets[options[:context].to_sym]
+          deep_merge!(self, newsets)
+        end
+      end
       
+      # save the Hash(self) in the file named by @config_file
+      # @return [TrueClass,FalseClass] true if save! successfull
+      def save!
+        res = false
+        File.open(@config_file, "w") do |f|
+          res = true if f.write(self.to_yaml)
+        end
+        return res
+      end
+
+
       private
-      # constructor type could be a section name in <get_sections> result
-      # override could be true of false and precise if the block of the application have 
-      # to override the main config hash result, default is true 
-      def initialize(_options)
+      # full recursive merger for hash 
+      def deep_merge!(target, data)
+        merger = proc{|key, v1, v2|
+          Settings === v1 && Settings === v2 ? v1.merge(v2, &merger) : v2 }
+        target.merge! data, &merger
+      end
+
+
+    end
+
+    
+    
+    
+    # Service Configuration of Carioca
+    class Configuration 
+      
+
+      
+      # @example 
+      #   config = Carioca::Services::Configuration::new :config_file => 'afilename', :context => 'production'
+      #   p config.config_file
+      #   config_file = 'newfilename'
+      # @attr_reader [String] the filename of the YAML struct
+      attr_accessor :settings
+
+      
+      # Configuration service constructor (open config)
+      # @param [Hash] _options the params
+      # @option _options [String] :config_file the filename of the config
+      def initialize(_options = {})
         options = Methodic.get_options(_options)
-        options.specify_classes_of :config_file => String
-        options.validate!
-        
-        
-        
-        
-        
+        options.specify_default_value :config_file => "./.config"
+        options.merge
+        @settings = Carioca::Services::Settings.new(options)
       end
       
-      def test(params)
-        return 'toto'
+      # Proxy to @settings.save! 
+      #  save the Hash(self) in the file named by @config_file
+      # @return [TrueClass,FalseClass] true if save! successfull
+      # @example usage
+      #   config = Carioca::Services::Configuration::new :config_file => 'afilename', :context => 'production'
+      #   config.config_file = 'newfile'   
+      #   config.save!
+      def save!
+        @settings.save!
+      end
+
+      
+      # reading wrapper to @settings.config_file accessor
+      # @return [String] @config_file the file name  
+      # @example usage
+      #   config = Carioca::Services::Configuration::new :config_file => 'afilename', :context => 'production'
+      #   p config.config_file 
+      def config_file
+        @settings.config_file
+      end
+      
+      # writting wrapper to @settings.config_file accessor
+      # @param [String] name the file name
+      # @example usage
+      #   config = Carioca::Services::Configuration::new :config_file => 'afilename', :context => 'production'
+      #   config.config_file = 'newfile'
+      def config_file=(name)
+        @settings.config_file = name
+      end
+
+
+      # garbage service hook
+      # @note close the logger
+      # @note call by Carioca::Services::Registry#close
+      def garbage
+        @settings = nil
+        return true
       end
       
     end
   end
-  
-  
-  
 end
 
 
+
+
+
 # interactive hacks 
 if $0 == __FILE__ then
+  conf =Carioca::Services::Configuration::new :config_file => 'spec/config/.config'
+  p conf
   puts "#{File::basename(__FILE__)}:"
   puts 'this is a RUBY library file'
   puts "Copyright (c) Ultragreen"

data/lib/services/debug.rb

@@ -1,4 +1,9 @@
 #!/usr/bin/env ruby
+# $BUILTIN
+# $NAME debug
+# $SERVICE Carioca::Services::ProxyDebug
+# $RESOURCE debug
+# $DESCRIPTION Proxy class debugger Service for Carioca
 # Copyright Ultragreen (c) 2012
 #---
 # Author : Romain GEORGES 
@@ -14,14 +19,18 @@ require 'methodic'
 module Carioca
   module Services
     
-    # standard RAA dependency
-    
     
+    # Service Debug of Carioca
+    # Proxy Class Debug for devs
     class ProxyDebug
       
+      # ProxyDebug service constructor (has a class proxy => so a service proxy)
+      # @param [Hash] _options the params
+      # @option _options [String] :service the name of the service you want to proxyfying
+      # @option _options [Hash] :params the params of the proxyfied service
       def initialize(_options)
         options = Methodic.get_options(_options)
-        options.specify_classes_of :service => String, :params => Hash
+        options.specify_classes_of :service => String
         options.specify_presence_of([:service])
         options.validate!
         if options[:params] then
@@ -33,26 +42,24 @@ module Carioca
         @mapped_service = options[:service]
       end
       
+      # method_missing overload to make the class proxy efficient 
       def method_missing(methodname, *args,&block)
         @log.debug("ProxyDebug") { "BEGIN CALL for mapped service #{@mapped_service} "} 
         @log.debug("ProxyDebug") { "called: #{methodname} " }
         @log.debug("ProxyDebug") { "args : #{args}" }
-
         if block_given? then
           @log.debug("ProxyDebug") { "block given" }
           a = @obj.send(methodname, *args,&block)
         else
-          
           a = @obj.send(methodname, *args)
         end
-
         @log.debug("ProxyDebug") { "=> returned: #{a} " }
         @log.debug("ProxyDebug") { 'END CALL' }
         return a
       end
+
+
     end
-    
-    
   end
 end
 
@@ -61,10 +68,6 @@ if $0 == __FILE__ then
   puts "#{File::basename(__FILE__)}:"
   puts 'this is a RUBY library file'
   puts "Copyright (c) Ultragreen"
-  puts "Version : #{Agents::LIB_VERSION}"
-  puts "Author : #{Agents::AUTHOR}"
-  puts "Date release : #{Agents::DATE}"
-  puts "Observation : #{Agents::OBS}"
 end
 
 

data/lib/services/logger.rb

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
+# $BUILTIN
+# $NAME logger
+# $SERVICE Carioca::Services::InternalLogger
+# $RESOURCE logger
+# $DESCRIPTION The standard ruby Logger internal wrapper Service for Carioca
+# $INIT_OPTIONS target => /tmp/log.file
 # Copyright Ultragreen (c) 2005
 #---
 # Author : Romain GEORGES 
@@ -7,31 +13,31 @@
 #---
 # $Id$
 
-
 require 'rubygems'
 require 'logger'
 require 'methodic'
 
 module Carioca
   module Services 
-    
+
+    # Service Logger (InternalLogger) of Carioca,
+    # @note integrally based on Logger from logger Gem
     class InternalLogger < Logger
       
       private
-      # constructor type could be a section name in <get_sections> result
-      # override could be true of false and precise if the block of the application have 
-      # to override the main config hash result, default is true 
-      def initialize(_options)
+      
+      # logger service constructor (open log)
+      # @param [Hash] _options the params 
+      # @option _options [String] :target the filename where to log
+      def initialize(_options = {})
         options = Methodic.get_options(_options)
-        options.specify_default_value_of :target => STDOUT
-        options.validate!
-        
+        options.specify_default_value :target => STDOUT
+        options.merge
         super(options[:target])
-        
-        
-        
       end
       
+      # garbage service hook
+      # @note close the logger 
       def garbage
         self.close
       end