rcs-common 9.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2b1ac857fbf21f06eb94d5a5e76cd178184b8ef
+  data.tar.gz: f6dc9cd9218eb48ac4a3a811edc3e7036266c0cb
+SHA512:
+  metadata.gz: acbf20309baa1c68b561a28063863183a983fea9944775ded0881f88a38ce3e04c3b92cb42b906abd4abd36d2b2ab2a0de282e65853172debc04341b972f30c1
+  data.tar.gz: 300985b94d6b9144ba3993032f29e6d008cbb1e2e00164b54157964b1dd6daf1a75282c6806991f3bcaa3f6456f6c29c814f76896fcf36f255ffe9880dbdb884

data/.gitignore

@@ -0,0 +1,49 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp
+
+# For RubyMine
+.idea
+
+# RVM gemset
+.ruby-gemset

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rcs-common.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1 @@
+Copyright (c) 2014 HT srl

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+Dir["./tasks/*.rake"].each do |path|
+  load(path)
+end
+
+desc "Run minitest"
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Run minitest + rspec"
+task :default do
+  Rake::Task["test"].invoke
+  Rake::Task["spec"].invoke
+end
+
+desc "Run rspec"
+RSpec::Core::RakeTask.new(:spec)
+
+# Disable the release task (release the gem to rubygems)
+Rake::Task["release"].clear

data/lib/rcs-common.rb

@@ -0,0 +1,21 @@
+# helper modules
+require 'rcs-common/time'
+require 'rcs-common/utf16le'
+
+require "rcs-common/version"
+
+# gem modules
+require 'rcs-common/crypt'
+require 'rcs-common/pascalize'
+require 'rcs-common/keywords'
+require 'rcs-common/sanitize'
+require 'rcs-common/trace'
+require 'rcs-common/mime'
+require 'rcs-common/systemstatus'
+require 'rcs-common/fixnum'
+require 'rcs-common/symbolize'
+require 'rcs-common/utf16le'
+require 'rcs-common/cgi'
+require 'rcs-common/binary'
+require 'rcs-common/stats'
+require 'rcs-common/gridfs'

data/lib/rcs-common/binary.rb

@@ -0,0 +1,64 @@
+
+# add a method to String to perform binary substitution
+# without the hassles of regexp
+
+class MatchNotFound < StandardError
+  def initialize
+    super "matching string not found"
+  end
+end
+
+class OutOfBounds < StandardError
+  def initialize
+    super "offset is out of bound"
+  end
+end
+
+class OutOfBoundsString < StandardError
+  def initialize
+    super "string too long, out of bound"
+  end
+end
+
+class String
+  def binary_patch(match, replace)
+    raise MatchNotFound unless self[match]
+    # use the block form to avoid the regexp in the replace string
+    self.gsub!(match.force_encoding('ASCII-8BIT')) do |param|
+      replace.force_encoding('ASCII-8BIT')
+    end
+  end
+
+  def binary_patch_at_offset(offset, replace)
+    io = StringIO.new(self)
+
+    # check for boundaries
+    raise OutOfBounds if offset < 0
+    raise OutOfBounds if offset > io.size
+    raise OutOfBoundsString if offset + replace.bytesize > io.size
+
+    io.pos = offset
+    io.write replace
+    io.close
+    self
+  end
+
+  def binary_add_at_offset(offset, value)
+    io = StringIO.new(self)
+
+    # check for boundaries
+    raise OutOfBounds if offset < 0
+    raise OutOfBounds if offset > io.size
+
+    io.pos = offset
+    current = io.read(4).unpack('I').first
+    current += value
+    current = [current].pack('I')
+
+    io.pos = offset
+    io.write current
+    io.close
+    self
+  end
+
+end

data/lib/rcs-common/cgi.rb

@@ -0,0 +1,7 @@
+require 'cgi'
+
+class CGI
+  def self.encode_query(hash)
+    return hash.map{|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join("&")
+  end
+end

data/lib/rcs-common/component.rb

@@ -0,0 +1,87 @@
+require 'rcs-common/trace'
+
+module RCS
+  module Component
+    def self.included(base)
+      base.__send__(:include, RCS::Tracer)
+      base.__send__(:extend, RCS::Tracer)
+
+      base.__send__(:extend, ClassMethods)
+
+      base.__send__(:define_singleton_method, :component) do |value, name: nil|
+        @_component = value.to_sym
+        @_component_name = name || "RCS #{value.to_s.capitalize}"
+      end
+    end
+
+    def component
+      self.class.instance_variable_get('@_component')
+    end
+
+    def component_name
+      self.class.instance_variable_get('@_component_name')
+    end
+
+    def full_component_version
+      File.read(Dir.pwd + '/config/VERSION').strip
+    end
+
+    def component_version
+      $version || full_component_version.split('-').first
+    end
+
+    def show_startup_message
+      build = File.read(Dir.pwd + '/config/VERSION_BUILD')
+      trace :fatal, "Starting the #{component_name} #{full_component_version} (#{build})..."
+    end
+
+    def database
+      @_database ||= begin
+        db_class =  RCS.const_get('Collector::DB') rescue RCS.const_get('DB::DB')
+        db_class.instance
+      end
+    end
+
+    def establish_database_connection(wait_until_connected: false)
+      loop do
+        connected = database.respond_to?(:connect!) ? database.connect!(component) : database.connect
+
+        if connected
+          trace :info, "Database connection succeeded"
+          break
+        end
+
+        if wait_until_connected
+          trace :warn, "Database connection failed, retry..."
+          sleep 1
+        else
+          trace :error, "Database connection failed"
+          break
+        end
+      end
+    end
+
+    def run_with_rescue
+      $version = component_version
+      trace_setup
+      show_startup_message
+      yield
+      return 0
+    rescue Interrupt
+      # call the kill handler if defined
+      kill if self.respond_to? :kill
+      trace :info, "User asked to exit. Bye bye!"
+      exit(0)
+    rescue Exception => e
+      trace :fatal, "FAILURE: " << e.message
+      trace :fatal, "EXCEPTION: [#{e.class}] " << e.backtrace.join("\n")
+      exit(1)
+    end
+
+    module ClassMethods
+      def run!(*argv)
+        return new.run(argv)
+      end
+    end
+  end
+end

data/lib/rcs-common/crypt.rb

@@ -0,0 +1,71 @@
+#
+# The encryption module.
+#   by default we use the PKCS5 padding
+#   force the third parameter to change the padding
+#
+
+require 'openssl'
+require 'digest/sha1'
+
+module RCS
+
+module Crypt
+  PAD_NOPAD = 0
+  PAD_PKCS5 = 1
+  SHA1_DIGEST_LENGTH = 20
+
+  def aes_encrypt(clear_text, key, padding=PAD_PKCS5)
+    cipher = OpenSSL::Cipher::Cipher.new('aes-128-cbc')
+    cipher.encrypt
+    cipher.padding = padding
+    cipher.key = key
+    cipher.iv = "\x00" * cipher.iv_len
+    edata = cipher.update(clear_text)
+    edata << cipher.final
+    return edata
+  end
+  
+  def aes_decrypt(enc_text, key, padding=PAD_PKCS5)
+    decipher = OpenSSL::Cipher::Cipher.new('aes-128-cbc')
+    decipher.decrypt
+    decipher.padding = padding
+    decipher.key = key
+    decipher.iv = "\x00" * decipher.iv_len
+    data = decipher.update(enc_text)
+    data << decipher.final
+    return data
+  end
+
+  def aes_encrypt_integrity(clear_text, key, padding=PAD_PKCS5)
+    # add the integrity check at the end of the message
+    clear_text += Digest::SHA1.digest(clear_text)
+    return aes_encrypt(clear_text, key, padding)
+  end
+
+  def aes_decrypt_integrity(enc_text, key, padding=PAD_PKCS5)
+    text = aes_decrypt(enc_text, key, padding)
+    # check the integrity at the end of the message
+    check = text.slice!(text.length - SHA1_DIGEST_LENGTH, text.length)
+    raise "Invalid sha1 check" unless check == Digest::SHA1.digest(text)
+    return text
+  end
+end
+
+end #namespace
+
+if __FILE__ == $0
+  require 'securerandom'
+  include RCS::Crypt
+  
+  clear = SecureRandom.random_bytes(16)
+  key = Digest::MD5.digest "4yeN5zu0+il3Jtcb5a1sBcAdjYFcsD9z"
+  
+  puts "DATA: " + clear.unpack('H*').to_s
+  enc = aes_encrypt(clear, key)
+  
+  puts "ENC: " + enc.unpack('H*').to_s
+  dec = aes_decrypt(enc, key)
+  
+  puts "DEC: " + dec.unpack('H*').to_s
+  
+end

data/lib/rcs-common/deploy.rb

@@ -0,0 +1,96 @@
+module RCS
+  class Deploy
+    attr_reader :me, :target
+
+    def initialize(params)
+      @target = Target.new(params)
+      @me = Me.new
+    end
+
+    class Me
+      attr_reader :path
+
+      def initialize
+        @path ||= File.expand_path(Dir.pwd)
+
+        raise "Missing rakefile" unless File.exists?("#{@path}/Rakefile")
+        raise "Not in a git repo" unless Dir.exists?("#{@path}/.git")
+      end
+
+      def run(cmd, opts = {})
+        puts "executing: #{cmd}"
+        opts[:trap] ? `#{cmd}` : Kernel.system(cmd)
+      end
+
+      def pending_changes?
+        run("cd \"#{path}\" && git status", trap: true) !~ /nothing to commit, working directory clean/
+      end
+
+      def ask(question, yes_no: true, choices: %w[y n])
+        print("#{question} (#{choices.join(', ')}): ")
+
+        begin
+          answer = STDIN.readline.strip.downcase
+          yes_no ? (answer == 'y' or answer == 'yes') : answer
+        rescue Interrupt
+          puts "\nBye"
+          exit
+        end
+      end
+    end
+
+    class Target
+      attr_reader :user, :address
+
+      def initialize(params)
+        @user = params[:user]
+        @address = params[:address]
+      end
+
+      def add_slash(path)
+        path.end_with?('/') ? "#{path}" : "#{path}/"
+      end
+
+      def transfer(src, remote_folder, opts = {})
+        dst = add_slash(remote_folder)
+
+        run_without_ssh("rsync -tcv #{src} #{user}@#{address}:\"#{dst}\"", opts)
+      end
+
+      def mirror!(local_folder, remote_folder, opts = {})
+        src = add_slash(local_folder)
+        dst = add_slash(remote_folder)
+
+        run_without_ssh("rsync --delete -vazc \"#{src}\" #{user}@#{address}:\"#{dst}\"", opts)
+      end
+
+      def mirror(local_folder, remote_folder, opts = {})
+        opts[:trap] = true
+        result = mirror!(local_folder, remote_folder, opts)
+        changes = result.split("\n")[1..-3].reject { |x| x.empty? }
+        changed = changes.size > 0 && changes != ["./"]
+
+        if opts[:changes]
+          changed ? result : nil
+        else
+          changed
+        end
+      end
+
+      def restart_service(name)
+        run_with_ssh("net stop \"#{name}\"; net start \"#{name}\"")
+      end
+
+      def run_with_ssh(command, opts = {})
+        run_without_ssh("ssh #{user}@#{address} \""+ command.gsub('"', '\"') +"\"", opts)
+      end
+
+      alias :run :run_with_ssh
+
+      def run_without_ssh(cmd, opts = {})
+        puts "executing: #{cmd}"
+        opts[:trap] ? `#{cmd}` : Kernel.system(cmd)
+      end
+    end
+  end
+end