rcs-common 9.6.0

data/lib/rcs-common/heartbeat.rb

@@ -0,0 +1,96 @@
+require 'rcs-common/trace'
+require 'rcs-common/systemstatus'
+require 'socket'
+
+module RCS::HeartBeat
+  class Base
+    extend RCS::Tracer
+    include RCS::Tracer
+    include RCS::SystemStatusCodes
+
+    # Declare the component
+    # To use as an helper in the subclasses
+    def self.component(component_name, component_fullname = nil)
+      @component_name     = component_name
+      @component_fullname = component_fullname
+    end
+
+    # This method is called from outside
+    def self.perform
+      heartbeat = new(@component_name, component_fullname: @component_fullname)
+      status, message = *heartbeat.perform
+      if status
+        heartbeat.update(status, message)
+      else
+        # trace(:warn, "heartbeat prevented")
+      end
+    rescue Interrupt
+      trace :fatal, "Heartbeat was interrupted because of a term signal"
+    rescue Exception => ex
+      trace :fatal, "Cannot perform heartbeat: #{ex.message}"
+      trace :fatal, ex.backtrace
+    end
+
+
+    def initialize(component_name, component_fullname: nil)
+      raise("Undefined component version") unless version
+      raise("Undefined component name") unless component_name
+
+      @component_name     = component_name.to_s.downcase
+      @component_fullname = component_fullname || "RCS::#{component_name.to_s.capitalize}"
+    end
+
+    def update(status, message)
+      system_status, system_message = *system_status_and_message
+
+      if status == OK and system_status != OK
+        status, message = system_status, system_message
+      end
+
+      attributes = [@component_fullname, hostname, status, message, machine_stats, @component_name, version]
+
+      if defined?(::Status)
+        # Db
+        ::Status.status_update(*attributes)
+      else
+        # Collector
+        db_class = Object.const_get(@component_fullname)::DB
+        attributes[1] = ''
+        db_class.instance.update_status(*attributes)
+      end
+    ensure
+      reset_system_status_and_message
+    end
+
+    # Override this method
+    def perform
+      system_status_and_message
+    end
+
+    private
+
+    def hostname
+      @hostname ||= Socket.gethostname rescue 'unknown'
+    end
+
+    def reset_system_status_and_message
+      RCS::SystemStatus.reset
+    end
+
+    def system_status_and_message
+      [RCS::SystemStatus.status, RCS::SystemStatus.message]
+    end
+
+    def version
+      $version
+    end
+
+    def machine_stats
+      {
+        disk: RCS::SystemStatus.disk_free,
+        cpu: RCS::SystemStatus.cpu_load,
+        pcpu: RCS::SystemStatus.my_cpu_load(@component_fullname)
+      }
+    end
+  end
+end

data/lib/rcs-common/keywords.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+# here we are re-opening the ruby String class,
+# the namespace must not be specified
+
+require_relative 'sanitize'
+
+class String
+
+  def keywords
+
+    # make a copy of itself to preserve the original
+    keywords = self.dup
+
+    # sanitize the input UTF-8
+    keywords.force_utf8!
+
+    # remove everything that is not alphanumeric
+    keywords.gsub!(/([^[:alnum:]])+/u, ' ')
+    #keywords.gsub!(/[(,%&@_":;!\#\-\*\[\]\{\}\?\\\+\'\.\/)]/, ' ')
+
+    # returns a copy of str with leading and trailing whitespace removed.
+    keywords.strip!
+
+    # convert to lowercase
+    keywords.downcase!
+
+    # split on spaces
+    keywords = keywords.split " "
+
+    # remove too long words
+    # it is with a very high probability a meaningless word (like encoded or something)
+    keywords.delete_if {|w| w.size > 25}
+
+    # remove duplicate words
+    keywords.uniq!
+
+    # sort the array
+    keywords.sort!
+
+    keywords
+  rescue Exception => e
+    #puts e.message if debug
+    #puts e.backtrace.first if debug
+    # fallback case
+    []
+  end
+
+end
+

data/lib/rcs-common/mime.rb

@@ -0,0 +1,65 @@
+#
+#  Mime Types handling module
+#
+
+# system
+require 'mime/types'
+
+# reopen the original class in order to add our specific mime types
+module MIME
+  class Types
+    # rename the original method to be used in our wrapper
+    alias mime_type_for type_for
+    
+    # our wrapper which adds our types
+    def type_for(filename, platform = false)
+      # call the original method
+      type = mime_type_for(filename, platform)
+      
+      if type.empty? then
+        case File.extname(filename)
+          when '.cod'
+            type = MIME::Type.from_array('application/vnd.rim.cod', 'cod', '8bit', 'linux')
+          when '.apk'
+            type = MIME::Type.from_array('application/vnd.android.package-archive', 'apk', '8bit', 'linux')
+          when '.aetx'
+            type = MIME::Type.from_array('application/x-aetx', 'aetx', '8bit', 'linux')
+          when '.xap'
+            type = MIME::Type.from_array('application/x-silverlight-app', 'xap', '8bit', 'linux')
+        end
+      end
+      return type
+    end
+  end
+end
+
+module RCS
+
+class MimeType
+
+  def self.get(file)
+    begin
+      # ask for the mime type
+      type = MIME::Types.type_for(file)
+
+      # if there are multiple choices, get the first one
+      type = type.first if type.is_a?(Array)
+    rescue Exception => e
+      type = nil
+    end
+
+    # special case for IE mobile not understanding this
+    if File.extname(file) == '.cab' then
+      type = MIME::Type.new('binary/octet-stream')
+    end
+
+    # default if none is found
+    type = MIME::Type.new('binary/octet-stream') if type.nil?
+
+    # convert from MIME::Type to String
+    return type.to_s
+  end
+end
+
+end #RCS::
+

data/lib/rcs-common/mongoid.rb

@@ -0,0 +1,19 @@
+require 'mongoid'
+
+# Monkey path serialization of BSON::ObjectId
+module BSON
+  class ObjectId
+    def as_json(*args)
+      to_s
+    end
+  end
+end
+
+# Fix #symbolize_key called on BSON::Document
+module BSON
+  class Document < ::Hash
+    def symbolize_keys
+      to_h.symbolize_keys
+    end
+  end
+end

data/lib/rcs-common/pascalize.rb

@@ -0,0 +1,62 @@
+# here we are re-opening the ruby String class,
+# the namespace must not be specified
+
+class String
+  
+  # returns a string encoded into a pascalized form
+  def pascalize
+    # the pascalized version is composed as follow:
+    # - 4 bytes len in front
+    # - UTF-16LE encoded string
+    # - UTF-16LE null terminator
+    pascalized = [self.encode('UTF-16LE').bytesize + 2].pack('I')
+    pascalized += self.encode('UTF-16LE').unpack('H*').pack('H*') 
+    pascalized += "\x00\x00"
+
+    # BINARY is an alias for ASCII-8BIT
+    return pascalized.encode!('ASCII-8BIT')
+  end
+  
+  # returns a string decoded from its pascalized form
+  def unpascalize
+    begin
+      # get the len (unsigned int 4 bytes)
+      len = self.unpack('I')
+      # sanity check to avoid
+      return nil unless len.first <= self.length - 4
+      # get the string
+      unpascalized = self.slice(4, len.first).force_encoding('UTF-16LE')
+      # convert to UTF-8
+      unpascalized.encode!('UTF-8')
+      # remove the trailing zero
+      unpascalized.chop!
+      
+      return unpascalized
+    rescue
+      return nil
+    end
+  end
+
+  # returns an array containing all the concatenated pascalized strings
+  def unpascalize_ary
+    many = []
+    buffer = self
+    len = 0
+    
+    begin
+      # len of the current token
+      len += buffer.unpack('I').first + 4
+      # unpascalize the token
+      str = buffer.unpascalize
+      # add to the result array
+      many << str unless str.nil?
+      # move the pointer after the token
+      buffer = self.slice(len, self.length)
+      # sanity check
+      break if buffer.nil?
+    end while buffer.length != 0
+    
+    return many
+  end
+end
+

data/lib/rcs-common/path_utils.rb

@@ -0,0 +1,67 @@
+module RCS
+  module Common
+  	module PathUtils
+      # Requires and rcs module. Sarch for a folder named rcs-NAME, where NAME is
+      # the given name, and requires a script named NAME.rb
+      #
+      # @note The current directory is changed (chdir command)
+      def require_component(name, opts = {})
+        $invocation_directory = Dir.pwd
+        $invocation_directory = ENV['CWD'] if ENV['CWD']
+
+        init_script = caller[0].scan(/^(.+)\:\d+\:.+$/)[0][0]
+
+        if init_script !~ /(bin|lib)\/rcs\-#{name}/
+          raise "Invalid execution directory"
+        end
+
+        $execution_directory = File.expand_path('../..', init_script)
+
+        #puts "WARN: chdir to #{$execution_directory}"
+        Dir.chdir($execution_directory)
+
+        require_release("#{$execution_directory}/lib/rcs-#{name}-release/#{name}.rb", warn: true)
+
+      rescue LoadError => error
+        puts "FATAL: cannot load component rcs-#{name}: #{error.message}"
+        puts error.backtrace.join(", ") if error.backtrace.respond_to?(:join)
+      end
+
+      # Requires an encrypted ruby script (rcs-XXX-releases folders) when
+      # available, otherwise requires the clean version of it (rcs-XXX folders)
+      def require_release(path, warn: false, required: true)
+        if path.include?("-release")
+          new_path = path
+        else
+          new_path = path.gsub(/(.*)rcs-([^\/]+)/, '\1rcs-\2-release')
+        end
+
+        if warn and !new_path.include?('-release') and File.exists?(new_path)
+          puts "WARNING: Executing clear text code... (debug only)"
+        end
+
+        begin
+          require(new_path)
+          return
+        rescue LoadError => error
+          # In this case, raise the LoadError only if it's caused
+          # by another #require inside the required script, otherwise
+          # go on and try to require the clean version
+          raise(error) if error.path != new_path
+        end
+
+        begin
+          new_path.gsub!('-release', '')
+          require(new_path)
+        rescue LoadError => error
+          raise(error) if required
+        end
+      end
+    end
+  end
+end
+
+unless Kernel.respond_to?(:require_release)
+  Kernel.__send__(:include, RCS::Common::PathUtils)
+  Object.__send__(:include, Kernel)
+end

data/lib/rcs-common/resolver.rb

@@ -0,0 +1,40 @@
+require 'resolv'
+require 'timeout'
+
+module RCS
+  module Resolver
+    def resolved_dns_cache
+      @@dns_cache ||= {}
+    end
+
+    def resolve_dns(dns, use_cache: false)
+      if use_cache and resolved_dns_cache[dns]
+        return resolved_dns_cache[dns]
+      end
+
+      ip = nil
+
+      Timeout::timeout(8) do
+        ip = Resolv.getaddress(dns).to_s rescue nil
+      end
+
+      if ip.nil? and defined?(Win32)
+        Timeout::timeout(10) do
+          info = Win32::Resolv.get_resolv_info
+          resolver = Resolv::DNS.new(nameserver: info[1], search: info[0])
+          ip = resolver.getaddress(dns).to_s rescue nil
+        end
+      end
+
+      raise("Cannot resolve DNS #{dns.inspect}: unknown host") unless ip
+
+      resolved_dns_cache[dns] = ip
+
+      return ip
+    rescue Timeout::Error
+      raise("Cannot resolve DNS #{dns.inspect}: timeout")
+    rescue Exception => ex
+      raise("Cannot resolve DNS #{dns.inspect}: #{ex.message}")
+    end
+  end
+end

data/lib/rcs-common/rest.rb

@@ -0,0 +1,17 @@
+require 'rcs-common/trace'
+
+module RCS
+  module Common
+    module Rest
+      STATUS_OK = 200
+      STATUS_REDIRECT = 302
+      STATUS_BAD_REQUEST = 400
+      STATUS_AUTH_REQUIRED = 401
+      STATUS_NOT_FOUND = 404
+      STATUS_NOT_AUTHORIZED = 403
+      STATUS_METHOD_NOT_ALLOWED = 405
+      STATUS_CONFLICT = 409
+      STATUS_SERVER_ERROR = 500
+    end
+  end
+end

data/lib/rcs-common/sanitize.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+# here we are re-opening the ruby String class,
+# the namespace must not be specified
+
+class String
+  REMOVE_INVALID_CHARS_REGEXP = Regexp.new(/([^[:alnum:][:graph:]\n\r])+/u)
+
+  def remove_invalid_chars
+    self.force_utf8.gsub(REMOVE_INVALID_CHARS_REGEXP, ' ')
+  end
+
+  def force_utf8(modify_self = false)
+    src_encoding = valid_encoding? ? encoding.to_s : 'BINARY'
+    dst_encoding = 'UTF-8'
+
+    args = [dst_encoding, src_encoding, {:invalid => :replace, :undef => :replace, replace: ''}]
+
+    modify_self ? encode!(*args) : encode(*args)
+  end
+
+  def force_utf8!
+    force_utf8(true)
+  end
+
+  def strip_html_tags
+    copy = self.dup
+
+    # Strip HTML tags
+    copy.gsub!(/<[^>]*>/, '')
+
+    # Strip encoded &amp; repetitively encoded HTML tags
+    copy.gsub!(/&amp;(amp;)*lt;.*?&amp;(amp;)*gt;/im, '')
+
+    # Strip HTML entities and repetitively encoded entities
+    # Or decode with http://htmlentities.rubyforge.org/
+    copy.gsub!(/&amp;(amp;)*((#x?)?[a-f0-9]+|[a-z]+);/i, ' ')
+
+    copy
+  end
+
+end