hypersonic-plus 0.0.0

data/lib/hdb/hpgsql.rb

@@ -0,0 +1,54 @@
+require 'hdb/hdb'
+
+class HPgSql < HDB
+  
+  def initialize(host, port, dbname, user, password, timezone, connectionName)
+
+    super(host, port, dbname, user, password, timezone, connectionName, "hpgsql")
+    @result = nil
+
+  end
+
+  def connect()
+
+    @connection = PGconn.new(@host, @port, "", "", @dbname, @user, @password)
+    hl << "Server version: #{self.execute("SHOW server_version").firstData.to_s}"
+    self.execute("SET TIME ZONE '#{@timezone}'") if @timezone
+    return @connection
+
+  end
+
+  def disconnect()
+
+    @connection.close()
+    @connection = nil
+
+  end
+
+  def _execute(queryStr = self.queryStr) 
+
+    @table = []
+    @result = @connection.query(queryStr)
+    @result.each do |row|  
+      @table << row
+    end
+    return self
+
+  end
+  
+  def fieldNameList()
+
+    fieldList = {}
+    
+    @result.fields.each { |fieldName| fieldList[fieldName] = nil }
+    
+    return fieldList
+
+  end
+
+  def rowsAffected
+    return @result.cmd_tuples()
+  end
+
+end
+

data/lib/hengine/application_controller.rb

@@ -0,0 +1,204 @@
+require 'bcrypt'
+require 'jbuilder'
+require 'json'
+require 'ostruct'
+require 'pg'
+require 'erb'
+require 'erubis'
+
+class ApplicationController
+  
+  attr_accessor :isRenderized
+
+  def initialize
+    @layouts = {}
+    @layout = "application"
+  end
+
+  def _hInit(controllerName, actionName)
+    @controllerName = controllerName
+    @actionName = actionName
+  end
+
+  def _readFile(filename)
+    file = File.open(filename,'r')
+    content = self._localVariable(@locals) + file.read 
+    file.close()
+    hl << content
+    return content
+  end
+
+  def heval(jsonStr)
+    # Quando converto un oggetto OpenStruct in json usando l'ambiente IRB ottengo il formato:
+    # "\"#<OpenStruct name=\\\"_herbert_\\\", bonaffini=\\\"_bonaffini_\\\">\""
+    if(jsonStr.index("#<OpenStruct"))
+      hl << "[application_controllet::heval]#: =========> first case".red
+      osn = eval(jsonStr).gsub(/#<OpenStruct.*>/) { |token| "{#{token.gsub('"', "'").gsub("=", ":").gsub("#<OpenStruct", "")[0..-2]}}" }
+      hash = eval(osn)
+      return OpenStruct.new hash
+    end 
+    # Quando converto un oggetto OpenStruct in json usando l'ambiente rails ottengo il formato:
+    # '{"table":{"name":"_herbert_","bonaffini":"_bonaffini_"},"modifiable":true}'
+    if(jsonStr.index('},"modifiable":true}')) 
+      hl << "[application_controllet::heval]#: =========> second case".red
+      hash = eval(jsonStr)[:table]
+      return OpenStruct.new hash
+    end
+    return eval(jsonStr)
+
+  end
+
+  # Questo metodo permette di avere le variabili locali di locals disponibili nel file erb
+  # file .rb
+  # - es. render(template: "test/index", layout: 'application', locals: {name: 'herbert', surname: 'bonaffini'})
+  # file .html.erb
+  # - es. <%= "Name: #{name}, Surname: #{@locals[:surname]}" %
+  def _localVariable(args)
+
+    return "" unless args
+    str = ""
+    args.each { |key, value| str += "#{key}=heval('#{value.to_json}');"; }
+    hl << "ApplicationController::_localVariable: #{str}"
+    return "<% #{str} %>"
+
+  end
+
+  def content_for(layoutName, &block)
+
+    @layouts[layoutName] = block
+
+  end
+
+  def herb(filename)
+    content = self._readFile(filename)
+    erb = ERB.new(content)
+    #erb = Erubis::Eruby.new(content)
+    return erb.result(binding())  
+  end
+
+  def execLayout(filename)
+
+    content = self._readFile(filename).gsub(/content_for.*(do|{)/) { |token| "#{token} _herbout=''" }
+    # To more information http://apidock.com/ruby/v1_9_3_392/ERB/Compiler
+    compiler = ERB::Compiler.new("<>")
+    compiler.pre_cmd    = ["_herbout=''"]
+    compiler.put_cmd    = "_herbout.concat"
+    compiler.insert_cmd = "_herbout.concat"
+    compiler.post_cmd   = [""]
+    code, enc = compiler.compile(content)
+    hl << code
+    eval(code)
+
+  end
+
+  def _setDefaultLayout(filename)
+   
+    result = self.herb(filename) 
+    self.content_for(:default) do
+      result
+    end
+
+  end
+
+  # by this method you can set another layout as on rails. It is enough to call layout in your controller
+  # example1: layout("layout_name")  # static
+  # example2: layout :determine_layout # dynamic where determine_layout is a method name
+  def layout(layout = nil)
+    @layout = layout if(layout) # it is required to work as a getter and setter
+    return @layout if(@layout.class == String)
+    return eval(@layout.to_s)
+  end
+  
+  def templateFileName (controllerName, actionName)
+    return @file if(@file)
+    return "./app/views/#{controllerName}/#{actionName}_view.html.erb"
+  end
+  
+  # il nome dei parziale deve inziare con _ e non deve contenere _view
+  def partialFileName (controllerName, actionName)
+    return "./app/views/#{controllerName}/#{actionName}.html.erb"
+  end
+
+  def __render(controllerName, actionName, &block)
+    templateFileName = self.templateFileName(controllerName, actionName)
+    layoutFileName = "./app/views/layouts/#{self.layout}.html.erb"
+    self._setDefaultLayout(templateFileName)
+    self.execLayout(templateFileName)
+    hl << @layouts[:default].call
+    return self.herb(layoutFileName, &block)
+  end
+
+
+  def _render(controllerName, actionName)
+
+    return self.__render(controllerName, actionName) do |layoutName|
+      if(layoutName)
+        @layouts[layoutName].call
+      else
+        @layouts[:default].call
+      end
+    end
+
+  end
+
+  # examples:
+  # render(template: "test/index") # can i use an other template
+  # render(layout: 'application')  # can i use an other layout
+  # render(action: 'hello')        # can i use an ./views/xxx/hello_view.html.erb
+  # render(text: 'ciao')           # return only the text 'ciao'
+  # render(json: {name: 'herbert', surname: 'von carean'}) # return an hash with json format
+  # render(file: "app/views/test/index_view.html.erb")
+
+  # file .rb
+  # - es. render(template: "test/index", layout: 'application', locals: {name: 'herbert', surname: 'bonaffini'})
+  # file .html.erb
+  # - es. <%= "Name: #{name}, Surname: #{@locals[:surname]}" %
+
+  def render(template: nil, action: nil, file: nil, text: nil, json: nil, layout: false, status: "200 OK", nothing: false, partial: nil, object: nil, locals: nil, collection: nil, spacer_template: nil)
+
+    hl << "isRenderized: #{@isRenderized}"
+    @isRenderized = true
+
+    # <%= render(partial: "article", collection: %w{ ant bee cat dog elk }, spacer_template: 'spacer') %>
+    if partial
+      @locals[partial] = object if object
+      return self.herb(self.partialFileName(@controllerName, "_#{partial}")) unless collection
+      result = ""
+      collection.each do |value| 
+        @locals = {}
+        @locals[partial] = value
+        result += self.herb(self.partialFileName(@controllerName, "_#{partial}")) 
+        result += self.herb(self.partialFileName(@controllerName, "_#{spacer_template}")) if spacer_template
+      end
+      return result
+    end
+    
+    @locals = locals
+
+    return "" if nothing
+
+    @layout = layout if layout.class == String
+
+    if(file)
+      @file = file
+      return self.render if layout
+      return self.herb(file)
+    end
+  
+    return text if text
+    
+    return json.to_json if json
+
+    return self._render(template.split('/')[0], template.split('/')[1]) if template
+        
+    return self._render(@controllerName, action) if action
+
+    return self._render(@controllerName, @actionName)
+
+  end
+
+
+end
+
+
+Dir.glob("app/controllers/**/*.rb").each { |filename| require "./#{filename}" }

data/lib/hengine/hconfiguration.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require "singleton"
+require "yaml"
+
+class HConfiguration
+
+  include Singleton 
+
+  def initialize()
+   @configurations = Hash.new
+   @configurations["CONFIGURATION"] = YAML.load_file('config/configuration.yml')
+   # eventuali altri configuration da caricare all'avvio
+  end
+
+  def configuration(configurationName)
+  
+    return @configurations[configurationName]
+
+  end  
+
+  def setValue(fieldValue, fieldName, configurationName = "CONFIGURATION")
+    self.configuration(configurationName)[fieldName] = fieldValue
+  end
+
+  def value(fieldName, configurationName = "CONFIGURATION")
+
+    return self.configuration(configurationName)[fieldName] 
+
+  end
+  
+
+end
+
+def hc()
+
+    return HConfiguration.instance()
+
+end
+

data/lib/hengine/hhotlogger.rb

@@ -0,0 +1,13 @@
+class HHotLogger
+
+  def self.append(str, logName)
+    log = hsd.value(logName)
+    return unless log
+    hsd.set(logName, log = {}) if log.class != Hash
+    timestamp = Time.now.to_s
+    log[timestamp] = [] unless log[timestamp]
+    log[timestamp] << str 
+  end
+    
+end
+

data/lib/hengine/hlogger.rb

@@ -0,0 +1,119 @@
+require 'date'
+
+class HLogger
+
+  # log on screen if filename is stdout
+  HLOG_MAXSIZE = 10 # 10MB
+  def initialize(filename, level: 'DEBUG')
+    @levels = self._levels 
+    @levelToNum = self._toNum
+    @level = @levelToNum[level]
+    return if(filename == "stdout")
+    filename = "logger.txt" if(filename == nil)
+    if (File.exist?(filename) and File.size(filename).to_f / 1000000 >= HLOG_MAXSIZE)
+      timestamp = DateTime.now.strftime "%d-%m-%Y-%H.%M.%S"
+      File.rename(filename, "#{filename}.#{timestamp}")
+    end
+    @file = File.new(filename, "a+")
+  end
+
+  def _levels
+    levels = []
+    levels << "OFF"
+    levels << "FATAL"
+    levels << "ERROR"
+    levels << "WARNING"
+    levels << "INFO"
+    levels << "DEBUG"
+    levels << "DEBUG2"
+    levels << "DEBUG3"
+    levels << "DEBUG4"
+    levels << "ALL"
+
+    return levels
+  end
+
+  def _toNum
+
+    levelToNum = {}
+    self._levels.each_with_index do |level, i|
+      levelToNum[level] = i
+    end
+    
+    return levelToNum
+
+  end
+
+  def toNum(strLevel)
+    return @levelToNum[strLevel]
+  end
+
+  def level(value)
+    
+    return @levels[value]
+
+  end
+
+  def close
+    @file.close if(@file)
+  end
+
+  def timestamp
+    return DateTime.now.strftime "%d-%m-%Y %H:%M:%S"
+  end
+
+  # hlogger << "hello world"
+  # hlogger.<<("hello world", "DEBUG") # warning: if i put some space doesn't work
+
+  def << (str, level = 'DEBUG')
+
+    level = self.toNum(level) if(level.class == String)
+  
+    return if(level > @level)
+
+    t = self.timestamp
+    strLevel = self.level(level)
+    if(@file)
+      @file << "[#{strLevel} #{t}]$ #{str}\n"
+    else
+      case self.level(level)
+      when "ERROR"
+        puts "[#{strLevel} hypersonic]$ #{str}".red 
+      when "FATAL"
+        puts "[#{strLevel} hypersonic]$ #{str}".red 
+      when "DEBUG"
+        puts "[#{strLevel} hypersonic]$ #{str}".green 
+      when "WARNING"
+        puts "[#{strLevel} hypersonic]$ #{str}".hight_cyan
+      when "INFO"
+        puts "[#{strLevel} hypersonic]$ #{str}".hight_purple 
+      else
+        puts "[#{strLevel} hypersonic]$ #{str}".white
+      end
+    end
+  
+    return self
+
+  end
+
+  # You can use this function more beautiful than .<<(...)
+  
+  def write(str, level)
+    self.<<(str, level)
+  end
+
+end
+
+
+
+def hlogger
+
+  return hsd.value("hlogger")
+
+end
+
+def hl 
+
+  return hlogger
+
+end

data/lib/hengine/hmalloc.rb

@@ -0,0 +1,275 @@
+require "singleton"
+
+class HNode
+ 
+  attr_reader :obj, :parentNode, :childNodes, :createTimestamp
+  attr_accessor :updateTimestamp
+
+  def initialize(obj, parentNode = nil, timestamp = Time.now.to_i)
+    @obj = obj
+    @createTimestamp = timestamp
+    @updateTimestamp = timestamp
+    @parentNode = parentNode 
+    @childNodes = []
+  end
+  
+  def self.showObj(obj: nil, margin: 0)
+    if obj.class == Hash
+      hl.<< ' ' * margin + "  => by connect: receiver: #{obj[:receiver].class} - method: #{obj[:method]}(#{obj[:args]})".green, "DEBUG2"
+    elsif 
+      hl.<< ' ' * margin + "  => by hm().malloc: #{obj}".green, "DEBUG2"
+    end
+  end
+
+  def showObj(margin: 0)
+    HNode.showObj(obj: @obj, margin: margin)
+  end  
+
+  def show(oid: nil, margin: 0)
+    
+    parentObj = @parentNode.obj if @parentNode
+    poid = parentObj.object_id if parentObj
+    str = "oid: #{oid} - #{@obj.class} - parent: #{parentObj.class} => poid: #{poid} - time: #{Time.at(@updateTimestamp).to_time.strftime("%H:%M:%S")}"
+
+    if poid
+      hl.<< ' ' * margin + str.yellow, "DEBUG2"
+    else
+      hl.<< ' ' * margin + str.red, "DEBUG2"
+    end
+    
+    self.showObj(margin: margin)
+
+  end
+
+  def showTree(oid: nil, margin: 0)
+    self.show(oid: oid, margin: margin)
+    @childNodes.each do |node|
+      node.showTree(margin: margin + 3)
+    end
+  end
+
+end
+
+class HMalloc
+
+  include Singleton
+
+  attr_reader :memory, :deallocated
+
+  def initialize
+    hl << "============== NEW HMALLOC ==============".red
+    @expiration = 15 * 60 # seconds
+    @memory = {}
+    @deallocated = {}
+  end
+
+  # poid: parent object id
+  def malloc(obj, poid = nil)
+    
+    oid = obj.object_id
+    poid = poid.to_i
+    parentNode = @memory[poid] if poid != 0
+    hl.<< "WARNING malloc: poid #{poid} not found", "ERROR" if poid != 0 and !parentNode
+
+    node = HNode.new(obj, parentNode)
+    # Se abilita la seguente istruzione non viene deallocata la memoria
+    #ObjectSpace.define_finalizer(obj, proc {|objectId| hl << "Finalizer of the #{objectId}" })
+
+    hl.<< "WARNING: #{oid} already exist".red, "ERROR" if @memory.include?(oid)
+    @memory[oid] = node
+    parentNode.childNodes << node if parentNode
+    hl.<< "[HMalloc.malloc]#: ".yellow, "DEBUG2"
+    hl.<< "WARNING: No parent".red, "ERROR" if poid == 0
+    node.show(oid: oid, margin: 3)
+    
+    return node
+
+  end
+  
+  def malloc2(obj, parent = nil)
+
+    return self.malloc(obj, parent.object_id)
+
+  end
+
+  def parentOf(oid)
+    return @memory[oid.to_i].parentNode.obj.object_id if oid
+  end
+
+  def getNode(oid)
+    oid = oid.to_i
+    node = @memory[oid]
+    self.hotLog("ERROR: HMalloc::getNode(#{oid}): #{oid} deallocated".red) if @deallocated[oid]
+    return nil unless node
+    node.updateTimestamp = Time.now.to_i
+    self.getNode(node.parentNode.obj.object_id) if node.parentNode # Aggiorna updateTimestamp dei genitori
+    return node
+  end
+  
+  def get(oid)
+    return self.getNode(oid).obj
+  end
+ 
+  def dealloc(oid, deleteFromParent = true)
+    return unless oid
+    oid = oid.to_i
+    node = @memory[oid]
+    hl << "WARNING: #{oid} not found".red unless node
+    self.hotLog("ERROR: HMalloc::dealloc(#{oid}): already deallocated") if @deallocated[oid]
+    return unless node
+    hl << "[HMalloc.dealloc]#:".green
+    node.show(oid: oid, margin: 3)
+    node.childNodes.clone.each do |childNode|
+      self.dealloc2(childNode.obj, false) 
+    end
+    node.parentNode.childNodes.delete(node) if node.parentNode and deleteFromParent
+    @memory.delete(oid)
+    @deallocated[oid] = true if hsd.value("log4memory")
+
+  end
+  
+  def dealloc2(obj, deleteFromParent = true)
+    return unless obj
+    return self.dealloc(obj.object_id, deleteFromParent)
+  end
+
+  def resetMemory()
+    hl << "Reset Memory ... 100%".hight_cyan
+    @memory = {}
+  end
+  
+  def hotLog(str)
+    HHotLogger.append(str, "log4memory")
+  end
+
+  def clean()
+
+    #GC.start(full_mark: true, immediate_sweep: true) # Start Gargabe Collection immediately and deletes every unused memory block
+    #Senza l'istruzione sopra la memoria viene liberata gradualmente ad es.
+    # - se ho 100 blocchi di memoria non usati ne vengolo liberati solo 40 per poi liberare la restante parte in un momento successivo
+    # - se invece eseguo GC.start sopra con immediate_sweep: true viene liberata tutta la memoria non usata con effetto immediato
+
+    to_delete = nil
+    to_delete = @memory.select do |oid, node| 
+      node.parentNode == nil and node.updateTimestamp  + @expiration <= Time.now.to_i 
+    end
+    hl << "[start cleaning]#: ...".hight_cyan
+    to_delete.each do |oid, node| 
+      self.dealloc(oid)
+    end
+
+  end
+
+  def show
+    
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#                                  Tree Hypersonic Memory Leak                                 #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "# Visualizzazione della memoria ad albero (non compare l'oid dei figli)                        #".hight_white, "DEBUG2" 
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "# Le seguenti allocazioni di memoria possono essere generate in due modi:                      #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - By connect: in questo caso la tabella sotto mostra il receiver, il metodo e i parametri  #".hight_white, "DEBUG2"
+    hl.<< "#     es. tr.connect(:ondblclick, self, 'doubleClick', id: @oid, ...)                          #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - By malloc: in questo caso la tabella sotto mostra l'oggetto usato                        #".hight_white, "DEBUG2"
+    hl.<< "#     es. @oid = hm().malloc(@modelName.clone, poid).obj.object_id.to_s                        #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - Le righe in rosso sono quelle senza parent (vericare che ce ne sia solo una)             #".hight_white, "DEBUG2"
+    hl.<< "#     Se ce sono piu' di una e si vuole capire da dove proviene il metodo alloc genera         #".hight_white, "DEBUG2"
+    hl.<< "#     un Warning rosso quando si esegue una malloc senza poid                                  #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    
+    memory = @memory.sort_by { |oid, node| node.updateTimestamp }
+    memory.each do |oid, node|
+      node.showTree(oid: oid) unless node.parentNode
+    end
+    
+    return memory
+
+  end
+  
+  def showAll(sorted: false)
+    
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#                                    Hypersonic Memory Leak                                    #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "# Le seguenti allocazioni di memoria possono essere generate in due modi:                      #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - By connect: in questo caso la tabella sotto mostra il receiver, il metodo e i parametri  #".hight_white, "DEBUG2"
+    hl.<< "#     es. tr.connect(:ondblclick, self, 'doubleClick', id: @oid, ...)                          #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - By malloc: in questo caso la tabella sotto mostra l'oggetto usato                        #".hight_white, "DEBUG2"
+    hl.<< "#     es. @oid = hm().malloc(@modelName.clone, poid).obj.object_id.to_s                        #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "#   - Le righe in rosso sono quelle senza parent (vericare che ce ne sia solo una)             #".hight_white, "DEBUG2"
+    hl.<< "#     Se ce sono piu' di una e si vuole capire da dove proviene il metodo alloc genera         #".hight_white, "DEBUG2"
+    hl.<< "#     un Warning rosso quando si esegue una malloc senza poid                                  #".hight_white, "DEBUG2"
+    hl.<< "#                                                                                              #".hight_white, "DEBUG2"
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+    usedMemory = "[Used Memory]#: #{@memory.length} blocks".hight_cyan
+    hl.<< "#   #{usedMemory}                                                           ".hight_white, "DEBUG2"
+    hl.<< "################################################################################################".hight_white, "DEBUG2"
+   
+    memory = (sorted) ? @memory.sort_by { |oid, node| node.updateTimestamp } : @memory
+    memory.each do |oid, node| 
+      node.show(oid: oid)
+    end
+  
+    return memory
+
+  end
+  
+  def test
+
+    m = hm()
+    a1 = "LevelA-1"
+    l1 = "Level 1"
+    l2a = "Level 2-a"
+    l2b = "Level 2-b"
+    l2c = "Level 2-c"
+    l3a = "Level 3-a"
+    l3b = "Level 3-b"
+    l3c = "Level 3-c"
+
+    node = m.malloc2(l1)
+    m.malloc2(a1)
+    m.malloc2(l2a, l1)
+    m.malloc2(l2b, l1)
+    m.malloc2(l2c, l1)
+    m.malloc2(l3a, l2a)
+    m.malloc2(l3b, l2a)
+    m.malloc2(l3c, l2a)
+
+    m.show
+    sleep(3)
+    p m.get(l3c.object_id)
+    m.clean # La cancellazione avviene solo impostazione @expiration = 3 in quanto sleep = 3
+    m.show
+
+  end
+
+end
+
+def hm()
+
+    return HMalloc.instance()
+
+end
+
+#hm().test
+
+#a = "herbert"
+#b = "bonaffini"
+#hm().malloc(a)
+#hm().malloc(b)
+#hm.show
+
+