omf_common 6.0.0 → 6.0.2.pre.1

data/lib/omf_common/default_logging.rb

@@ -37,5 +37,16 @@ module OmfCommon
     def warn(*args, &block)
       logger.warn(*args, &block)
     end
+
+    # Log a warning message for deprecated methods
+    def warn_deprecation(deprecated_name, *suggest_names)
+      logger.warn "[DEPRECATION] '#{deprecated_name}' is deprecated. Please use '#{suggest_names.join(', ')}' instead."
+    end
+
+    def warn_removed(deprecated_name)
+      define_method(deprecated_name) do |*args, &block|
+        logger.warn "[DEPRECATION] '#{deprecated_name}' is deprecated and not supported. Please do not use it."
+      end
+    end
   end
 end

data/lib/omf_common/eventloop.rb

@@ -84,7 +84,21 @@ module OmfCommon
     def on_stop(&block)
       warn "Missing implementation 'on_stop'" 
     end
+    
+    # Calling 'block' when having trapped an INT signal
+    #
+    def on_int_signal(&block)
+      # trap(:INT)
+      warn "Missing implementation 'on_int_signal'" 
+    end
 
+    # Calling 'block' when having trapped a TERM signal
+    #
+    def on_term_signal(&block)
+      # trap(:TERM) {}
+      warn "Missing implementation 'on_term_signal'" 
+    end
+       
     private
     def initialize(opts = {}, &block)
       #run(&block) if block

data/lib/omf_common/eventloop/em.rb

@@ -25,15 +25,43 @@ module OmfCommon
         end
       end
 
+      # Call 'block' in the context of a separate thread.
+      #
+      def defer(&block)
+        raise "Can't handle 'defer' registration before the EM is up" unless EM.reactor_running?
+        EM.defer do
+          begin
+            block.call()
+          rescue  => ex
+            error "Exception '#{ex}'"
+            debug "#{ex}\n\t#{ex.backtrace.join("\n\t")}"
+          end
+        end
+      end
+
       # Periodically call block every interval_sec
       #
       # @param [Float] interval in sec
       def every(interval_sec, &block)
-        if EM.reactor_running?
-          EM.add_periodic_timer(interval_sec, &block)
-        else
-          @deferred << lambda do
-            EM.add_periodic_timer(interval_sec, &block)
+        # to allow canceling the periodic timer we need to
+        # hand back a reference to it which responds to 'cancel'
+        # As this is getting rather complex when allowing for
+        # registration before the EM is up and running, we simply throw
+        # and exception at this time.
+        raise "Can't handle 'every' registration before the EM is up" unless EM.reactor_running?
+        # if EM.reactor_running?
+          # EM.add_periodic_timer(interval_sec, &block)
+        # else
+          # @deferred << lambda do
+            # EM.add_periodic_timer(interval_sec, &block)
+          # end
+        # end
+        EM.add_periodic_timer(interval_sec) do
+          begin
+            block.call()
+          rescue  => ex
+            error "Exception '#{ex}'"
+            debug "#{ex}\n\t#{ex.backtrace.join("\n\t")}"
           end
         end
       end
@@ -43,7 +71,12 @@ module OmfCommon
           @deferred.each { |proc| proc.call }
           @deferred = nil
           if block
-            block.arity == 0 ? block.call : block.call(self)
+            begin
+              block.arity == 0 ? block.call : block.call(self)
+            rescue  => ex
+              error "While executing run block - #{ex}"
+              error ex.backtrace.join("\n\t")
+            end
           end
         end
       end

data/lib/omf_common/eventloop/local_evl.rb

@@ -31,6 +31,21 @@ module OmfCommon
         @tasks << [Time.now + interval_sec, block, :periodic => interval_sec]
       end
       
+      # Call 'block' in the context of a separate thread.
+      #
+      def defer(&block)
+        @logger.note("DEFER")
+        Thread.new do
+          begin
+            block.call()
+          rescue  => ex
+            @logger.error "Exception '#{ex}'"
+            @logger.debug ex.backtract.join("\n\t")
+          end
+        end
+      end
+      
+      
       def stop 
         @running = false
       end

data/lib/omf_common/exec_app.rb

@@ -32,7 +32,7 @@ require 'fcntl'
 # Borrows from Open3
 #
 class ExecApp
-
+  
   # Holds the pids for all active apps
   @@all_apps = Hash.new
 
@@ -69,25 +69,27 @@ class ExecApp
   #
   # Run an application 'cmd' in a separate thread and monitor
   # its stdout. Also send status reports to the 'observer' by
-  # calling its "on_app_event(eventType, appId, message")"
+  # calling its "call(eventType, appId, message")"
   #
   # @param id ID of application (used for reporting)
   # @param observer Observer of application's progress
   # @param cmd Command path and args
   # @param map_std_err_to_out If true report stderr as stdin [false]
   #
-  def initialize(id, observer, cmd, map_std_err_to_out = false)
+  def initialize(id, cmd, map_std_err_to_out = false, working_directory = nil, &observer)
 
     @id = id
     @observer = observer
     @@all_apps[id] = self
+    @exit_status = nil
+    @threads = []
 
     pw = IO::pipe   # pipe[0] for read, pipe[1] for write
     pr = IO::pipe
     pe = IO::pipe
 
     logger.debug "Starting application '#{id}' - cmd: '#{cmd}'"
-    @observer.on_app_event(:STARTED, id, cmd)
+    @observer.call(:STARTED, id, cmd)
     @pid = fork {
       # child will remap pipes to std and exec cmd
       pw[1].close
@@ -103,6 +105,7 @@ class ExecApp
       pe[1].close
 
       begin
+        Dir.chdir working_directory if working_directory
         exec(cmd)
       rescue => ex
         cmd = cmd.join(' ') if cmd.kind_of?(Array)
@@ -118,23 +121,31 @@ class ExecApp
     monitor_pipe(:stdout, pr[0])
     monitor_pipe(map_std_err_to_out ? :stdout : :stderr, pe[0])
     # Create thread which waits for application to exit
-    Thread.new(id, @pid) do |id, pid|
+    @threads << Thread.new(id, @pid) do |id, pid|
       ret = Process.waitpid(pid)
-      status = $?
+      @exit_status = $?.exitstatus
       @@all_apps.delete(@id)
       # app finished
-      if (status == 0) || @clean_exit
-        s = "OK"
+      if (@exit_status == 0) || @clean_exit
         logger.debug "Application '#{id}' finished"
       else
-        s = "ERROR"
-        logger.debug "Application '#{id}' failed (code=#{status})"
+        logger.debug "Application '#{id}' failed (code=#{@exit_status})"
       end
-      @observer.on_app_event("DONE.#{s}", @id, "status: #{status}")
     end
     @stdin = pw[1]
+    
+    # wait for done in yet another thread
+    Thread.new do
+      @threads.each {|t| t.join }
+      if (@exit_status == 0) || @clean_exit
+        s = "OK"
+      else
+        s = "ERROR"
+      end
+      @observer.call("DONE.#{s}", @id, "status: #{@exit_status}")
+    end
   end
-
+    
   private
 
   #
@@ -145,16 +156,19 @@ class ExecApp
   # @param pipe Pipe to read from
   #
   def monitor_pipe(name, pipe)
-    Thread.new() do
+    @threads << Thread.new() do
       begin
         while true do
           s = pipe.readline.chomp
-          @observer.on_app_event(name.to_s.upcase, @id, s)
+          #puts "#{name}: #{s}"
+          @observer.call(name.to_s.upcase, @id, s)
         end
       rescue EOFError
         # do nothing
-      rescue Exception => err
+        #puts "++++ STOP MONITORING #{name}"
+      rescue  => err
         logger.error "monitorApp(#{@id}): #{err}"
+        logger.debug "#{err}\n\t#{err.backtrace.join("\n\t")}"
       ensure
         pipe.close
       end

data/lib/omf_common/message.rb

@@ -26,9 +26,10 @@ module OmfCommon
       }
     }
     @@message_class = nil
+    @@authenticate_messages = false
 
     def self.create(type, properties, body = {})
-      @@message_class.create(type, properties, body)
+      @@message_class.create(type, properties || {}, body)
     end
 
     def self.create_inform_message(itype = nil, properties = {}, body = {})
@@ -36,10 +37,19 @@ module OmfCommon
       create(:inform, properties, body)
     end
 
-    # Create and return a message by parsing 'str'
+    # Return true if all messages will be authenticated, return false otherwise
     #
-    def self.parse(str)
-      @@message_class.parse(str)
+    def self.authenticate?
+      @@authenticate_messages
+    end
+
+    # Parse message from 'str' and pass it to 'block'.
+    # If authnetication is on, the message will only be handed
+    # to 'block' if the source of the message can be authenticated.
+    #
+    def self.parse(str, content_type = nil, &block)
+      raise ArgumentError, 'Need message handling block' unless block
+      @@message_class.parse(str, content_type, &block)
     end
 
     def self.init(opts = {})
@@ -60,6 +70,7 @@ module OmfCommon
       else
         raise "Missing provider class info - :constructor"
       end
+      @@authenticate_messages = opts[:authenticate] if opts[:authenticate]
     end
 
     OMF_CORE_READ.each do |pname|
@@ -116,7 +127,15 @@ module OmfCommon
       raise NotImplementedError
     end
 
+    def properties
+      raise NotImplementedError
+    end
+
     def has_properties?
+      not properties.empty?
+    end
+
+    def guard?
       raise NotImplementedError
     end
 
@@ -138,11 +157,32 @@ module OmfCommon
       self.class.create_inform_message(itype, properties, body)
     end
 
+    # Fetch inform type
+    #
+    # When no format provided, return the value as it is.
+    #
+    # @param [Symbol] format to render itype, valid formats: :ruby, :frcp
+    #
+    def itype(format = nil)
+      if format && !_get_core(:itype).nil?
+        case format.to_sym
+        when :ruby
+          _get_core(:itype).to_s.downcase.gsub(/\./, '_')
+        when :frcp
+          _get_core(:itype).to_s.upcase.gsub(/_/, '.')
+        else
+          raise ArgumentError, "Unknown format '#{format}'. Please use ':ruby, :frcp' instead."
+        end
+      else
+        _get_core(:itype)
+      end
+    end
+
     def to_s
       raise NotImplementedError
     end
 
-    def marshall
+    def marshall(include_cert = false)
       raise NotImplementedError
     end
 
@@ -171,6 +211,14 @@ module OmfCommon
     def  _set_property(name, value, ns = nil)
       raise NotImplementedError
     end
+
+    def _set_core(key, value)
+      raise NotImplementedError
+    end
+
+    def _get_core(key)
+      raise NotImplementedError
+    end
   end
 
 end

data/lib/omf_common/message/json/json_message.rb

@@ -1,42 +1,107 @@
 
 require 'json'
+require 'omf_common/auth'
+require 'json/jwt'
 
 module OmfCommon
   class Message
     class Json
       class Message < OmfCommon::Message
-        
+
+        # This maps properties in the internal representation of
+        # a message to names used for the JSON message
+        #
+        @@key2json_key = {
+          operation: :op,
+          res_id: :rid
+        }
 
         def self.create(type, properties, body = {})
-          if type == :request 
+          if type == :request
             unless properties.kind_of?(Array)
               raise "Expected array, but got #{properties.class} for request message"
             end
             properties = {select: properties}
           elsif not properties.kind_of?(Hash)
             raise "Expected hash, but got #{properties.class}"
-          end 
+          end
           content = body.merge({
-            operation: type,
+            op: type,
             mid: SecureRandom.uuid,
-            properties: properties
+            props: properties
           })
           self.new(content)
         end
-        
+
         def self.create_inform_message(itype = nil, properties = {}, body = {})
           body[:itype] = itype if itype
           create(:inform, properties, body)
         end
-        
+
         # Create and return a message by parsing 'str'
         #
-        def self.parse(str)
-          content = JSON.parse(str, :symbolize_names => true)
-          #puts content
-          new(content)
+        def self.parse(str, content_type, &block)
+          #puts "CT>> #{content_type}"
+          case content_type.to_s
+          when 'jwt'
+            content = parse_jwt(str, &block)
+          when 'text/json'
+            content = JSON.parse(str, :symbolize_names => true)
+          else
+            warn "Received message with unknown content type '#{content_type}'"
+          end
+          #puts "CTTT>> #{content}::#{content.class}"
+          msg = content ? new(content) : nil
+          block.call(msg) if msg
+          msg
+        end
+
+        def self.parse_jwt(jwt_string)
+          key_or_secret = :skip_verification
+          # Code lifted from 'json-jwt-0.4.3/lib/json/jwt.rb'
+          case jwt_string.count('.')
+          when 2 # JWT / JWS
+            header, claims, signature = jwt_string.split('.', 3).collect do |segment|
+              UrlSafeBase64.decode64 segment.to_s
+            end
+            header, claims = [header, claims].collect do |json|
+              #MultiJson.load(json).with_indifferent_access
+              JSON.parse(json, :symbolize_names => true)
+            end
+            signature_base_string = jwt_string.split('.')[0, 2].join('.')
+            jwt = JSON::JWT.new claims
+            jwt.header = header
+            jwt.signature = signature
+
+            # NOTE:
+            #  Some JSON libraries generates wrong format of JSON (spaces between keys and values etc.)
+            #  So we need to use raw base64 strings for signature verification.
+            unless src = claims[:iss]
+              warn "JWT: Message is missing :iss element"
+              return nil
+            end
+            if cert_pem = claims[:crt]
+              # let's the credential store take care of it
+              OmfCommon::Auth::CertificateStore.instance.register_x509(cert_pem, src)
+            end
+            unless cert = OmfCommon::Auth::CertificateStore.instance.cert_for(src)
+              warn "JWT: Can't find cert for issuer '#{src}'"
+              return nil
+            end
+
+            unless cert.verify_cert
+              warn "JWT: Invalid certificate '#{cert.to_s}', NOT signed by root certificate."
+            end
+
+            #puts ">>> #{cert.to_x509.public_key}::#{signature_base_string}"
+            jwt.verify signature_base_string, cert.to_x509.public_key #unless key_or_secret == :skip_verification
+            JSON.parse(claims[:cnt], :symbolize_names => true)
+          else
+            warn('JWT: Invalid Format. JWT should include 2 or 3 dots.')
+            return nil
+          end
         end
-                
+
         def each_property(&block)
           @properties.each do |k, v|
             #unless INTERNAL_PROPS.include?(k.to_sym)
@@ -44,16 +109,21 @@ module OmfCommon
             #end
           end
         end
-        
+
+        def properties
+          @properties
+        end
+
+
         def has_properties?
           not @properties.empty?
         end
-        
+
         def valid?
           true # don't do schema verification , yet
         end
-        
-        # Loop over all the unbound (sent without a value) properties 
+
+        # Loop over all the unbound (sent without a value) properties
         # of a request message.
         #
         def each_unbound_request_property(&block)
@@ -66,9 +136,9 @@ module OmfCommon
               block.call(el)
             end
           end
-        end    
-    
-        # Loop over all the bound (sent with a value) properties 
+        end
+
+        # Loop over all the bound (sent with a value) properties
         # of a request message.
         #
         def each_bound_request_property(&block)
@@ -83,47 +153,87 @@ module OmfCommon
               end
             end
           end
-        end    
-        
-                
+        end
+
+
         def to_s
           "JsonMessage: #{@content.inspect}"
         end
-        
-        def marshall
-          @content.to_json
+
+        # Marshall message into a string to be shipped across the network.
+        # Depending on authentication setting, the message will be signed as
+        # well, or maybe even dropped.
+        #
+        # @param [Topic] topic for which to marshall
+        #
+        def marshall(topic)
+          #puts "MARSHALL: #{@content.inspect} - #{@properties.to_hash.inspect}"
+          raise "Missing SRC declaration in #{@content}" unless @content[:src]
+          if @content[:src].is_a? OmfCommon::Comm::Topic
+            @content[:src] = @content[:src].id
+          end
+          #raise 'local/local' if @content[:src].id.match 'local:/local'
+          #puts @content.inspect
+          payload = @content.to_json
+          if self.class.authenticate?
+             src = @content[:src]
+             cert = OmfCommon::Auth::CertificateStore.instance.cert_for(src)
+             if cert && cert.can_sign?
+               debug "Found cert for '#{src} - #{cert}"
+               msg = {cnt: payload, iss: src}
+               unless @certOnTopic[k = [topic, src]]
+                 # first time for this src on this topic, so let's send the cert along
+                 msg[:crt] = cert.to_pem_compact
+                 #ALWAYS ADD CERT @certOnTopic[k] = Time.now
+               end
+               #:RS256, :RS384, :RS512
+               p = JSON::JWT.new(msg).sign(cert.key , :RS256).to_s
+               #puts "SIGNED>> #{msg}"
+               return ['jwt', p]
+             end
+          end
+          ['text/json', payload]
         end
-        
-        private 
+
+        private
         def initialize(content)
           debug "Create message: #{content.inspect}"
-          @content = content
-          unless op = content[:operation]
+          unless op = content[:op]
             raise "Missing message type (:operation)"
           end
-          content[:operation] = op.to_sym # needs to be symbol
-          @properties = content[:properties] || []
+          @content = {}
+          content[:op] = op.to_sym # needs to be symbol
+          if src = content[:src]
+            content[:src] = OmfCommon.comm.create_topic(src)
+          end
+          content.each {|k,v| _set_core(k, v)}
+          @properties = content[:props] || []
           #@properties = Hashie::Mash.new(content[:properties])
+          @authenticate = self.class.authenticate?
+          # keep track if we sent local certs on a topic. Should do this the first time
+          @certOnTopic = {}
         end
-        
+
         def _set_core(key, value)
-          @content[key] = value
+          @content[(@@key2json_key[key] || key).to_sym] = value
         end
 
         def _get_core(key)
-          @content[key]
+          @content[@@key2json_key[key] || key]
         end
-        
-        def _set_property(key, value)
+
+        def _set_property(key, value, ns = nil)
+          warn "Can't handle namespaces yet" if ns
           @properties[key] = value
         end
 
-        def _get_property(key)
+        def _get_property(key, ns = nil)
+          warn "Can't handle namespaces yet" if ns
           #puts key
           @properties[key]
         end
-        
+
       end # class
     end
   end
-end 
+end