lims-core 3.2.3

data/lib/lims-core/base.rb

@@ -0,0 +1,132 @@
+# vi: ts=2 sts=2 et sw=2 spell spelllang=en  
+require 'common'
+
+module Lims::Core
+  module Base
+    def self.included(klass)
+      klass.class_eval do
+        include Virtus
+        include Aequitas
+        include AccessibleViaSuper
+        extend Forwardable
+        extend ClassMethod
+      end
+    end
+
+    module AccessibleViaSuper
+      def initialize(*args, &block)
+        # readonly attributes are normaly not allowed in constructor
+        # by Virtus. We need to call set_attributes explicitely
+        options = args.extract_options!
+        # we would use `options & [:row ... ]` if we could
+        # but Sequel redefine Hash#& ...
+        initializables = self.class.attributes.select {|a| a.options[:initializable] == true  }
+        initial_options  = options.subset(initializables.map(&:name))
+        set_attributes(initial_options)
+        super(*args, options - initial_options, &block).tap {
+        }
+      end
+
+      # Like attributes but allow class to define a version
+      # without side effet.
+      # For example attribute on a UuidResource will generate an uuid.
+      # This is the method called by dirty_key_for
+      def attributes_for_dirty
+        attributes
+      end
+
+    end
+    # Compare 2 resources.
+    # They are == if they have the same values (attributes),
+    # regardless they are the same ruby object or not.
+    # @param other
+    # @return [Boolean]
+    def ==(other)
+      self.attributes == (other.respond(:attributes) || {} )
+    end
+
+
+    module ClassMethod
+      def is_array_of(child_klass, options = {},  &initializer)
+        define_method :initialize_array do |*args|
+          @content = initializer ? initializer[self, child_klass] : []
+        end
+
+        class_eval do
+          include Enumerable
+          include IsArrayOf
+          def_delegators :@content, :each, :size , :each_with_index, :map, :zip, :clear, :empty?, :to_s \
+            , :include?, :to_a, :first, :last
+
+        end
+      end
+
+    end
+
+
+    module IsArrayOf
+
+      def initialize(*args, &block)
+        super(*args, &block)
+        initialize_array()
+      end
+
+      # Add content to compare
+      # If classe are not in the same hierarchy we only compare the content
+      # @param other to compare with
+      # @return [Boolean]
+      def ==(other)
+        if other.is_a?(self.class) || self.is_a?(other.class)
+          super(other)
+        else 
+          !other.nil?
+        end && self.to_a == other.to_a
+      end
+
+      # The underlying array. Use to everything which is not directly delegated 
+      # @return [Array]
+      def content
+        @content 
+      end
+
+      # Delegate [] to the underlying array.
+      # This is needed because Virtus redefine [] as well 
+      # @param [Fixnum, ... ] i index
+      # @return [Object]
+      def [](i)
+        case i
+        when Fixnum then self.content[i]
+        else super(i)
+        end
+      end
+
+      def []=(i, value)
+        case i
+        when Fixnum then self.content[i]=value
+        else super(i, value)
+        end
+      end
+      # iterate only between non empty lanes.
+      # @yield [content]
+      # @return itself
+      def each_content
+        @content.each do |content|
+          yield content if content
+        end
+      end
+    end 
+
+    class HashString < Virtus::Attribute::Object
+      primitive Hash
+      def coerce(hash)
+        hash.rekey  {|key| key.to_s }
+      end
+    end
+
+    # @todo override state_machine to automatically add
+    # attribute
+    class State < Virtus::Attribute::Object
+      primitive String
+    end
+  end
+end

data/lib/lims-core/helpers.rb

@@ -0,0 +1,41 @@
+module Lims::Core
+  module Helpers
+    def self.gem_available?(gem_name)
+      begin
+        Gem::Specification.find_by_name(gem_name)
+      rescue Gem::LoadError
+        false
+      end
+    end
+
+    # Load the available gem for json
+    if gem_available?('jrjackson')
+      require 'jrjackson'
+      def self.to_json(object)
+        JrJackson::Json.dump(object)
+      end
+
+      def self.load_json(json)
+        JrJackson::Json.load(json)
+      end
+    elsif gem_available?('oj')
+      require 'oj'
+      def self.to_json(object)
+        Oj.dump(object, :mode => :compat)
+      end
+
+      def self.load_json(json)
+        Oj.load(json)
+      end
+    else
+      require 'json'
+      def self.to_json(object)
+        object.to_json
+      end
+
+      def self.load_json(json)
+        JSON.parse(json)
+      end
+    end
+  end
+end

data/lib/lims-core/persistence.rb

@@ -0,0 +1,15 @@
+#vi: ts=2 sw=2 et
+require 'common'
+require 'facets/string'
+
+require 'lims-core/persistence/session'
+
+module Lims::Core
+  # Generic persistence layer.
+  # The main objects are {Persistence::Session Session} which
+  # is in charge of saving and restoring object and {Persistence::Store} via Persistors.
+  # Persistors are mixins specific to each persistence types.
+  # For example, see the {Sequel::Persistor}.
+  module Persistence
+  end
+end

data/lib/lims-core/persistence/comparison_filter.rb

@@ -0,0 +1,54 @@
+require 'lims-core/persistence/filter'
+require 'lims-core/resource'
+
+
+module Lims::Core
+  module Persistence
+    # Filter performing a comparison between the resource field's value 
+    # and a given value.
+    # Key being the name of the resource's field and the value is a Hash.
+    # The key of the hash is a comparison operator
+    # and the value is the given value the filter do the comparison against.
+    #
+    # @example
+    #
+    # "model": "kit",
+    # "criteria": {
+    #     "comparison": {
+    #         "expires": {
+    #             ">=": "2013-04-24"
+    #         }
+    #     }
+    # }
+    #
+    # Will look for all kits expires after the given date ("2013-04-24").
+    #
+    class ComparisonFilter <  Filter
+      include Resource
+
+      NOT_IN_ROOT = 1
+
+      attribute :criteria, Hash, :required => true
+
+      # For Sequel, keys needs to be a Symbol to be seen as column.
+      # String are seen as 'value'
+      def initialize(criteria)
+        criteria = { :criteria => criteria } unless criteria.include?(:criteria)
+        criteria[:criteria].rekey!{ |k| k.to_sym }
+        super(criteria)
+      end
+
+      def call(persistor)
+        persistor.comparison_filter(criteria[:comparison])
+      end
+    end
+  end
+
+  class Persistor
+    # @param [Hash] criteria a 
+    # @return [Persistor] 
+    def comparison_filter(criteria)
+      raise NotImplementedError, "comparison_filter methods needs to be implemented for subclass of Persistor"
+    end
+  end
+end

data/lib/lims-core/persistence/filter.rb

@@ -0,0 +1,23 @@
+#vi: ts=2 sw=2 et
+require 'common'
+
+module Lims::Core
+  module Persistence
+    # @abstract Base class of all filters.
+    # A filter acts on persistors and can be chained.
+    # Note: This class is not really usefull in a *Ruby world* and is mainly
+    # here for documentation.
+    class Filter
+      # Transform a persistor to a "filtered persistor"
+      # The filtered persistor loading only the filtered object.
+      # Note that the actual implementation of the filter depends on the 
+      # *type* of the persistor (Sequel for example).
+      # @param persistor [Persistence::Persistor]
+      # @return [Persistor]
+      def call(persistor)
+        raise NotImplementedError
+      end
+    end
+  end
+end
+

data/lib/lims-core/persistence/identity_map.rb

@@ -0,0 +1,55 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+require 'common'
+
+module Lims::Core
+  module Persistence
+    # Mixing giving  an identity map behavior
+    # ie a map (both way) between id and object
+    module IdentityMap
+      # Raised if there is any duplicate in the identity map 
+      class DuplicateError < RuntimeError 
+      end
+
+      #Raised if the `id` is already associated to a different `object`
+      class DuplicateIdError <DuplicateError
+      end
+
+      #Raised if the `object` is already associated to a different `id`
+      class DuplicateObjectError < DuplicateError
+      end
+
+      # Look for the id associated to an object and yield it to the block
+      # if found.
+      def id_for(object, &block)
+        @object_to_id[object].andtap(&block)
+      end
+
+      # Look for the object associated to an object and yield it to the block
+      # if found.
+      def object_for(id, &block)
+        @id_to_object[id].andtap(&block)
+      end
+
+      # bound an id to an object
+      def map_id_object(id, object)
+        return nil unless id && object
+        raise DuplicateIdError, id unless @id_to_object.fetch(id, object).equal? object
+        raise DuplicateObjectError, object unless  @object_to_id.fetch(object, id).equal? id
+        @id_to_object[id] = object
+        @object_to_id[object] = id
+      end
+
+      def initialize(*args, &block)
+        super(*args, &block)
+        @id_to_object = {}
+        @object_to_id = {}
+      end
+
+      # Class version
+      class Class
+        include IdentityMap
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/logger/all.rb

@@ -0,0 +1,5 @@
+require('lims-core/persistence/logger/persistor')
+require('lims-core/persistence/logger/session')
+require('lims-core/persistence/logger/store')
+require('lims-core/persistence/message_bus')
+require('lims-core/persistence/persistor')

data/lib/lims-core/persistence/logger/persistor.rb

@@ -0,0 +1,35 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+
+module Lims::Core
+  module Persistence
+    module Logger
+      # Mixin giving extended the persistor classes with
+      # the Logger (save) behavior.
+      module Persistor
+        private
+
+        # Load an object to the underlying logger
+        # @param [Resource] object the object 
+        # @return  the Id if save successful
+        def save_raw(object, *params)
+          case object 
+            when Resource then @session.log("#{object.class.name}: #{filter_attributes_on_save(object.attributes)}")
+            else
+            @session.log("#{object.inspect}")
+            end
+          object
+        end
+
+        def save_as_aggregation(source_id, target, *params)
+          @session.with_indent("#{params} - ") do
+            super(source_id, target)
+          end
+        end
+
+        def save_raw_association(source_id, target_id, *params)
+        end
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/logger/session.rb

@@ -0,0 +1,30 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+require 'logger'
+require 'lims-core/persistence/session'
+
+module Lims::Core
+  module Persistence
+    module Logger
+      # Logger specific implementation of a {Persistence::Session Session}.
+      class Session < Persistence::Session
+
+        attr_reader :indent_level
+        def initialize(*args, &block)
+          @indent_level = ""
+          super(*args, &block)
+        end
+
+        def log(msg)
+          @store.log(indent_level+msg)
+        end
+
+        # Execute a block with the specified indent level indicator.
+        # @param [String] indent the indent level indicator
+        def with_indent(indent=" - ", &block)
+          temporarily('@indent_level' => @indent_level+indent, &block)
+        end
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/logger/store.rb

@@ -0,0 +1,37 @@
+# vi: ts=2:sts=2:et:sw=2
+
+require 'logger'
+require 'lims-core/persistence'
+require 'lims-core/persistence/store'
+require 'lims-core/persistence/logger/session'
+require 'lims-core/persistence/logger/persistor'
+
+module Lims::Core
+  module Persistence
+    module Logger
+      # An Logger::Store, a store 'logging' object instead of 
+      # saving them.
+      class Store < Persistence::Store
+        attr_reader :logger
+        attr_reader :method
+
+        # Create a store with an underlying logger.
+        # @param [Logger, file] logger 
+        # @param [Symbol, String] method the method call to
+        # send information to the logger.
+        def initialize(logger, method=:info, *args)
+          @logger = case logger
+                    when ::Logger then  logger
+                    else ::Logger.new(logger)
+                    end
+          @method = method
+          super(*args)
+        end
+
+        def log(msg)
+          @logger.send(@method, msg)
+        end
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/message_bus.rb

@@ -0,0 +1,131 @@
+require 'bunny'
+require 'common'
+
+module Lims
+  module Core
+    module Persistence
+
+      # Basic methods to publish messages on the bus
+      # Use the bunny gem as RabbitMQ client
+      class MessageBus
+
+        include Virtus
+        include Aequitas 
+        attribute :connection_uri, String, :required => true, :writer => :private
+        attribute :exchange_name, String, :required => true, :writer => :private
+        # By default, exchange_type is topic
+        attribute :exchange_type, String, :required => true, :writer => :private
+        attribute :durable, Boolean, :required => true, :writer => :private
+        attribute :prefetch_number, Integer, :required => true, :writer => :private
+        attribute :heart_beat, Integer, :required => false, :writer => :private
+        attribute :backend_application_id, String, :required => true
+
+        # Exception ConnectionError raised after a failed connection
+        # to RabbitMQ server.
+        class ConnectionError < StandardError
+        end 
+
+        # Exception InvalidSettingsError raised after a setting error
+        class InvalidSettingsError < StandardError
+        end
+
+        # Initialize the message bus and check the required options 
+        # are passed as parameters.
+        # @param [Hash] settings
+        def initialize(settings = {})
+          raise InvalidSettingsError, "MessageBug settings are empty" if settings == nil
+          @heart_beat = settings["heart_beat"]
+          @connection_uri = settings["url"]
+          @exchange_name = settings["exchange_name"]
+          @exchange_type = settings["exchange_type"] || "topic"
+          @durable = settings["durable"]
+          @prefetch_number = settings["prefetch_number"]
+          @backend_application_id = settings["backend_application_id"]
+        end
+
+        # sets backend_app_id, but just once,
+        # otherwise raise am InvalidSettings error
+        def backend_application_id=(backend_application_id)
+          raise InvalidSettingsError, "Backend Application ID has been set already." if @backend_application_id
+          @backend_application_id = backend_application_id
+        end
+
+        # Executed after a connection loss
+        # The exception should be catched and rollback the actions.
+        def connection_failure_handler
+          Proc.new do
+            raise ConnectionError, "can't connect to RabbitMQ server"
+          end
+        end
+
+        # Create a new connection to the broker using
+        # the connection settings.
+        # Create a channel and setup a new exchange.
+        def connect
+          begin
+            if valid?
+              options = @heart_beat ? { :heartbeat => heart_beat } : {}
+              @connection = Bunny.new(connection_uri, options)
+              @connection.start
+              @channel = @connection.create_channel
+              set_prefetch_number(prefetch_number)
+              set_exchange(exchange_name, :durable => durable)
+            else
+              raise InvalidSettingsError, "settings are invalid"
+            end
+          rescue Bunny::TCPConnectionFailed, Bunny::PossibleAuthenticationFailureError => e
+            connection_failure_handler.call
+          end
+        end  
+
+        # Close the connection
+        def close
+          @connection.close
+        end
+
+        # Create (or get if it already exists) a new topic
+        # exchange with the given options.
+        # Especially, the durable option can be set here to
+        # mark the exchange as durable (survive a server restart)
+        # @param [String] name
+        # @param [Hash] exchange options
+        def set_exchange(exchange_name, options = {})
+          @exchange = Bunny::Exchange.new(@channel, exchange_type.to_sym, exchange_name , options)
+        end
+        private :set_exchange
+
+        # Specifies the number of messages to prefetch.
+        # @param [int] number of messages to prefetch
+        def set_prefetch_number(number)
+          @channel.prefetch(number)
+        end
+        private :set_prefetch_number
+
+        # Set the message persistence behaviour.
+        # If persistent, the message will be persisted to disk
+        # and remain in the queue until it is consumed. 
+        # Survive a server restart.
+        # BUNNY ISSUE: bunny0.9pre4 hardcodes the persistent option. 
+        # @see lib/bunny/channel.rb:174 :delivery_mode => 2
+        # It is set all the time, meaning the messages will survive 
+        # a server restart, if the queue and the exchange are durable.
+        # @param [Bool] persistence
+        def set_message_persistence(persistent)
+          @message_persistence = persistent 
+        end
+
+        # Publish a message on the bus with the given options
+        # The routing key is passed in the options.
+        # @param [String] JSON message
+        # @param [Hash] publishing options
+        def publish(message, options = {})
+          raise ConnectionError, "exchange is not reachable" unless @exchange.instance_of?(Bunny::Exchange)
+          
+          options.merge!(:persistent => @message_persistence) unless @message_persistence.nil?
+          options.merge!(:app_id => @backend_application_id) if @backend_application_id
+          @exchange.publish(message, options)
+        end
+      end
+    end
+  end 
+end