pampa_workers 0.0.39

data/lib/remotedivision.rb

@@ -0,0 +1,8 @@
+module BlackStack
+
+  class RemoteDivision
+      attr_accessor :name
+      include BlackStack::BaseDivision
+  end # RemoteDivision
+
+end # module BlackStack

data/lib/remoteworker.rb

@@ -0,0 +1,8 @@
+module BlackStack
+
+  class RemoteWorker
+      attr_accessor :id, :process, :last_ping_time, :name, :active, :id_division, :assigned_process, :id_object, :division_name, :ws_url, :ws_port, :division
+      include BlackStack::BaseWorker
+  end # Remote Worker
+  
+end # module BlackStack

data/lib/role.rb

@@ -0,0 +1,8 @@
+module BlackStack
+  class Role < Sequel::Model(:role)
+    BlackStack::Role.dataset = BlackStack::Role.dataset.disable_insert_output
+  
+    ROLE_PRISMA_USER = "prisma.user"
+  
+  end
+end # module BlackStack

data/lib/timezone.rb

@@ -0,0 +1,151 @@
+module BlackStack
+  class Timezone < Sequel::Model(:timezone)
+    BlackStack::Timezone.dataset = BlackStack::Timezone.dataset.disable_insert_output
+  
+    # Recibe un string con formato "+HH:MM".
+    # Retorna la cantidad de horas como un numero real, con decimales.
+    def self.descToFloat(s)
+      sign = s[0]
+      if (sign=="+")
+        n = 1.0
+      else
+        n = -1.0
+      end
+      hours = s[1..2]
+      minutes = s[4..5]
+      int_part = hours.to_f
+      dec_part = minutes.to_f / 60.00
+      ret = n*(int_part + dec_part)    
+      return ret.to_f 
+    end
+  
+    # Recibe la cantidad de horas como un numero real, con decimales.
+    # Retorna un string con formato "+HH:MM".
+    def self.floatToDesc(x)
+      int_part = x.to_i
+      dec_part = (x-int_part.to_f).round(2).abs
+      hours = int_part
+      minutes = (dec_part * 60.00).to_i    
+      if (hours<0)
+        desc = "%03d" % hours 
+      else
+        desc = "+" + "%02d" % hours
+      end
+      desc += ":" + "%02d" % minutes
+      return desc
+    end
+  
+    # Example: '-03:00'
+    # Example: ' 08:00'
+    def self.getDatabaseOffset()
+      dbtime = DB["select SYSDATETIMEOFFSET() AS o"].first[:o].to_s
+  #puts ""
+  #puts ""
+  #puts "dbtime:#{dbtime.to_s}:."
+  #puts ""
+  #puts ""
+      ret = "#{dbtime[-5..-3]}:#{dbtime[-2..-1]}" 
+      ret[0] = '+' if ret[0]!='-'
+  #puts ""
+  #puts ""
+  #puts "dbtime:#{ret.to_s}:."
+  #puts ""
+  #puts ""
+      return ret
+    end
+  
+    # Convierte el atributo offset en un string con formato de hora.
+    # Ejemplos: 5.0 => 05:00, 5.5 => 05:30, -5.75 => -05:45   
+    def offsetDescription()
+      return BlackStack::Timezone.floatToDesc(self.offset.to_f)
+    end
+    
+    # Convierte una hora almacenada en el servidor de bases de datos, a la hora en esta zona horaria.
+    # Recibe un string con formato "+HH:MM".
+    # Retorna un string con formato "+HH:MM".
+    def convertFromThisTimeZoneToDatabaseTime(s_time_in_client_timezone)
+      f_time_in_client_timezone = BlackStack::Timezone.descToFloat(s_time_in_client_timezone)
+      s = BlackStack::Timezone.getDatabaseOffset()
+      x = BlackStack::Timezone.descToFloat(s) # database offset
+      y = self.offset # client offset
+      z = y - x 
+      return BlackStack::Timezone.floatToDesc((f_time_in_client_timezone.to_f + z.to_f).modulo(24))
+    end
+  
+    # Convierte una hora almacenada en el servidor de bases de datos, a la hora en esta zona horaria.
+    # Recibe un string con formato "+HH:MM".
+    # Retorna un string con formato "+HH:MM".
+    def convertFromDatabaseTimeToThisTimeZone(s_time_in_database)
+      f_time_in_database = BlackStack::Timezone.descToFloat(s_time_in_database)
+      s = BlackStack::Timezone.getDatabaseOffset()
+      x = BlackStack::Timezone.descToFloat(s) # database offset
+      y = self.offset # client offset
+      z = y - x 
+      return BlackStack::Timezone.floatToDesc((f_time_in_database.to_f - z.to_f).modulo(24))
+    end
+  
+    # Convierte una fecha-hora almacenada en el servidor de bases de datos, a la hora en esta zona horaria.
+    # Recibe un string con formato "YYYY-MM-DD HH:MM:SS".
+    # Retorna un string con formato "YYYY-MM-DD HH:MM:SS".
+    def convertFromDatabaseDateTimeToThisTimeZone(s_datetime_in_database)
+      s = BlackStack::Timezone.getDatabaseOffset() # Example: '-03:00'
+  #puts ""
+  #puts ""
+  #puts "s:#{s.to_s}:."
+  #puts ""
+  #puts ""
+      x = BlackStack::Timezone.descToFloat(s) # database offset. Number of hours, with decimals
+  #puts ""
+  #puts ""
+  #puts "x:#{x.to_s}:."
+  #puts ""
+  #puts ""
+      y = self.offset # client offset
+  #puts ""
+  #puts ""
+  #puts "y:#{y.to_s}:."
+  #puts ""
+  #puts ""
+      z = y - x 
+  #puts ""
+  #puts ""
+  #puts "z:#{z.to_s}:."
+  #puts ""
+  #puts ""
+      ret = DB["SELECT DATEADD(HH, #{z.to_s}, '#{s_datetime_in_database}') AS o"].first[:o].to_s[0..18]
+  #puts ""
+  #puts ""
+  #puts "convertFromDatabaseDateTimeToThisTimeZone:#{ret}:."
+  #puts ""
+  #puts ""
+  
+      return ret
+    end
+    
+    # 
+    def get_now()
+      datetime1 = DB["SELECT GETDATE() AS o"].first[:o].to_s[0..18]
+      datetime2 = self.convertFromDatabaseDateTimeToThisTimeZone(datetime1)
+  #puts ""
+  #puts ""
+  #puts "timezone:#{self.large_description}:."
+  #puts "datetime1:#{datetime1}:."
+  #puts "datetime2:#{datetime2}:."
+  #puts ""
+  #puts ""
+      yy = datetime2[0..3] # yyyy-mm-dd hh:mi:ss
+      mm = datetime2[5..6]
+      dd = datetime2[8..9]
+      hh = datetime2[11..12]
+      mi = datetime2[14..15]
+      ss = datetime2[17..18]
+  #puts ""
+  #puts ""
+  #puts "get_now:#{yy}-#{mm}-#{dd} #{hh}:#{mi}:#{ss}:."
+  #puts ""
+  #puts ""
+      return Time.new(yy,mm,dd,hh,mi,ss)
+    end
+    
+  end
+end # module BlackStack

data/lib/user.rb

@@ -0,0 +1,25 @@
+module BlackStack
+  class User < Sequel::Model(:user)
+    BlackStack::User.dataset = BlackStack::User.dataset.disable_insert_output
+    many_to_one :client, :class=>:'BlackStack::Client', :key=>:id_client
+    one_to_many :user_roles, :class=>:'BlackStack::UserRole', :key=>:id_user
+  
+  # TODO: agregar todos los arrays de un usuario
+  # => one_to_many :searches, :class=>:Search, :key=>:id_user
+  # => one_to_many :emlist, :class=>:EmList, :key=>:id_user
+  # => one_to_many :emlist, :class=>:EmList, :key=>:id_user
+  # => etc.
+  
+    # retorna la primera division habilitada a la que pertenezca este usuario
+    def division
+      row = DB[
+      "SELECT d.id " +
+      "FROM division d WITH (NOLOCK) " +
+      "JOIN user_division ud WITH (NOLOCK) ON (d.id=ud.id_division AND ud.id_user='#{self.id}') " +
+      "WHERE ISNULL(d.available,0) = 1 "
+      ].first
+      return nil if row.nil?
+      return BlackStack::Division.where(:id=>row[:id]).first if !row.nil?
+    end  
+  end # class User
+end # module BlackStack

data/lib/userdivision.rb

@@ -0,0 +1,5 @@
+module BlackStack
+  class UserDivision < Sequel::Model(:user_division)
+    BlackStack::UserDivision.dataset = BlackStack::UserDivision.dataset.disable_insert_output
+  end
+end # module BlackStack

data/lib/userrole.rb

@@ -0,0 +1,8 @@
+module BlackStack
+  class UserRole < Sequel::Model(:user_role)
+    BlackStack::UserRole.dataset = BlackStack::UserRole.dataset.disable_insert_output
+    many_to_one :user, :class=>:'BlackStack::User', :key=>:id_user
+    many_to_one :role, :class=>:'BlackStack::Role', :key=>:id_role
+  
+  end
+end # module BlackStack

data/lib/worker.rb

@@ -0,0 +1,234 @@
+module BlackStack
+
+  # 
+  class WorkerJob < Sequel::Model(:workerjob)
+     
+  end
+
+  # 
+  class Worker < Sequel::Model(:worker) 
+    include BlackStack::BaseWorker
+    BlackStack::Worker.dataset = BlackStack::Worker.dataset.disable_insert_output
+    many_to_one :division, :class=>:'BlackStack::Division', :key=>:id_division
+    many_to_one :user, :class=>:'BlackStack::User', :key=>:id_user
+=begin
+    # deprecated
+    # Actualiza la la lista de workers que estan asignados esta division
+    def self.updateAllFromCentral()
+      uri = URI("#{WORKER_API_SERVER_URL}/api1.3/pampa/get_all.json")
+      res = Net::HTTP.post_form(uri, {:api_key => BlackStack::Pampa::api_key,})
+      parsed = JSON.parse(res.body)
+      if (parsed['status'] != "success")
+        raise parsed['status'].to_s
+      else
+        parsed['workers'].each { |worker|
+          if ( worker['division_name']!=DATABASE )
+            q = "UPDATE worker SET active=0, division_name='#{worker['division_name']}' WHERE name='#{worker['name']}'"
+            DB.execute(q)
+          else # worker['division_name']==DIVISION_NAME   
+            
+            worker = BlackStack::Worker.where(:name=>worker['name']).first
+            if (worker==nil)
+              worker = BlackStack::Worker.new()
+              worker.id = worker['id']
+              worker.name = worker['name'].to_s
+              worker.last_ping_time = now() # esta fecha es actualiada por el mismo worker, para indicar que esta vivo y trabajando
+              worker.id_division = worker['id_division']
+              worker.process = worker['assigned_process']
+              worker.assigned_process = worker['assigned_process'] 
+              worker.id_object = worker['id_object']
+              worker.division_name = worker['division_name']
+              worker.save()
+            else
+              #puts "update" ?            
+            end
+            
+            DB.execute("UPDATE worker SET active=1 WHERE name='#{worker['name'].to_s}'")
+  
+            if (worker['id_division'] != nil)
+              DB.execute("UPDATE worker SET id_division='#{worker['id_division'].to_s}' WHERE name='#{worker['name'].to_s}'")
+            end
+  
+            if (worker['assigned_process'] != nil)
+              DB.execute("UPDATE worker SET process='#{worker['assigned_process'].to_s}', assigned_process='#{worker['assigned_process'].to_s}' WHERE name='#{worker['name'].to_s}'")
+            end
+  
+            if (worker['id_object'] != nil)
+              DB.execute("UPDATE worker SET id_object='#{worker['id_object'].to_s}' WHERE name='#{worker['name'].to_s}'")
+            end
+  
+            if (worker['division_name'] != nil)
+              DB.execute("UPDATE worker SET division_name='#{worker['division_name'].to_s}' WHERE name='#{worker['name'].to_s}'")
+            end
+  
+            if (worker['type']==nil || worker['type'].to_i==MyProcess::TYPE_LOCAL)
+              DB.execute("UPDATE worker SET type=#{MyProcess::TYPE_LOCAL.to_s} WHERE name='#{worker['name'].to_s}'")
+            else
+              DB.execute("UPDATE worker SET type=#{MyProcess::TYPE_REMOTE.to_s} WHERE name='#{worker['name'].to_s}'")
+            end
+          end
+          
+          # release resources
+          DB.disconnect
+          GC.start
+        }
+        
+      end
+    end
+  
+    # actualiza el rol y objeto asignado a este worker 
+    def updateFromCentral()
+      uri = URI("#{WORKER_API_SERVER_URL}/api1.3/pampa/get.json")
+      res = Net::HTTP.post_form(uri, {'api_key' => BlackStack::Pampa::api_key, 'name' => self.name})
+      parsed = JSON.parse(res.body)
+      if (parsed['status'] != "success")
+        raise parsed['status'].to_s
+      else  
+        # map response
+        self.id_division        = parsed['id_division']
+        self.assigned_process   = parsed['assigned_process']
+        self.id_object          = parsed['id_object']
+        self.division_name      = parsed['division_name']
+        self.active             = true
+  
+        if (parsed['id_object'].to_s.size>0)
+          aux_id_object = "'#{parsed['id_object']}'"
+        else
+          aux_id_object = "NULL"
+        end
+  
+        # NOTA: DEBO HACER EL UPDATE POR FUERA DE SQUEL, DEBIDO AL BUG DE MAPEO DE SEQUEL
+        q =
+        "UPDATE worker SET " +
+        "active=1, id_division='#{parsed['id_division']}', assigned_process='#{parsed['assigned_process'].to_s.gsub("'","''")}', id_object=#{aux_id_object}, division_name='#{parsed['division_name'].to_s.gsub("'","''")}' " +
+        "WHERE id='#{self.id}'"
+        DB.execute(q)      
+      end
+    end
+  
+    # actualiza el rol y objeto asignado a cada worker asignado a esta division 
+    def self.updateActivesFromCentral()
+      BlackStack::Worker.getActives().each { |worker|
+        worker.updateFromCentral()
+      }
+    end
+=end
+  
+    # 
+    def factory(name, params)
+      w = BlackStack::Worker.where(:name=>name).first
+      if (w==nil)
+        w = BlackStack::Worker.new
+      end
+      w.id                  = parsed['id']
+      w.name                = name
+      w.assigned_process    = parsed['assigned_process']
+      w.id_object           = parsed['id_object']
+      w.id_division         = parsed['id_division']
+      w.division_name       = parsed['division_name']
+      w.ws_url              = parsed['ws_url']
+      w.ws_port             = parsed['ws_port']
+      w.save
+    end
+  
+    # Retorna true si este worker esta corriendo en nuestros propios servidores, 
+    # Retorna false si este worker esta correiendo en otro host, asumiendo que es el host del cliente.
+    # Comparando la pulic_ip_address del worer con la lista en BlackStack::Pampa::set_farm_external_ip_addresses.  
+    def hosted?
+      BlackStack::Pampa::set_farm_external_ip_addresses.inlude?(self.public_ip_address)
+    end # hosted?
+    
+    # Si es un worker hosteado en nuestos servidores (ver metodo hosted?), 
+    # => retorna la cantidad de dias que fa
+    def expirationDesc
+      s = "(unknown)"
+      if self.hosted?
+        if !self.expiration_time.nil?
+          s = DB["SELECT DATEDIFF(mi, GETDATE(), w.expiration_time) AS n FROM worker w WHERE w.id='#{self.id}'"].first[:n].to_i.to_time_spent
+        end 
+      else # no hosted
+        s = "(self-hosted)"
+      end
+      s
+    end 
+  
+    # Retorna la cantidad de minutos desde que este worker envio una senial de vida. 
+    # Este metodo se usa para saber si un worker esta activo o no.
+    def last_ping_minutes()
+      q = "SELECT DATEDIFF(mi, p.last_ping_time, getdate()) AS minutes FROM worker p WHERE p.id='#{self.id}'"
+      return DB[q].first[:minutes].to_i
+    end
+
+    # returns true if this worker had got a ping within the last 5 minutes 
+    def active?
+      self.last_ping_minutes < BlackStack::BaseWorker::KEEP_ACTIVE_MINUTES
+    end
+
+    # escribe en el archivo de log de este worker
+    def log(s, level=1, is_error=false)
+      logw(s, self.process, self.id, level, is_error)
+    end
+  
+    # envia una senial de vida a la division
+    # TODO: guardar fecha-hora del ultimo ping en un atributo privado, y evitar el acceso escesivo a la base de datos
+    def ping()
+      DB.execute("UPDATE worker SET last_ping_time=GETDATE() WHERE id='#{self.id}'")
+    end
+    
+    # DEPRECATED
+    def self.getActivesCount(processName)
+      raise "Method needs some code inside."
+    end
+  
+    # obtiene array de workers actives, filtrados por proceso y por tipo de worker.
+    def self.getActives(assigned_process_name=nil, worker_name_filter=nil)
+      a = Array.new
+      q = ""
+      if (assigned_process_name!=nil)
+        q =
+            "SELECT p.id AS [id] " +
+            "FROM worker p WITH (NOLOCK INDEX(IX_peer__process__last_ping_time)) " + 
+            "WHERE last_ping_time>DATEADD(mi,-5,GETDATE()) " +
+            "AND ISNULL(active,0)=1 " + # active indica si este worker fue asignado a esta division en la central
+            "AND assigned_process='#{assigned_process_name}' "
+  
+        if worker_name_filter != nil
+          q = q +
+            "AND p.name LIKE '%#{worker_name_filter.to_s}%' "
+        end
+        
+        q = q +
+            "ORDER BY p.name "
+        DB[q].all do |row|
+          a << BlackStack::Worker.where(:id=>row[:id]).first
+        end
+      else
+        q =
+            "SELECT p.id AS [id] " +
+            "FROM worker p WITH (NOLOCK INDEX(IX_peer__process__last_ping_time)) " + 
+            "WHERE last_ping_time>DATEADD(mi,-5,GETDATE()) " +
+            "AND ISNULL(active,0)=1 "
+  
+        if worker_name_filter != nil
+          q = q +
+            "AND p.name LIKE '%#{worker_name_filter.to_s}%' "
+        end
+  
+        q = q +
+            "ORDER BY p.name "
+        DB[q].all do |row|
+          a << BlackStack::Worker.where(:id=>row[:id]).first
+        end
+      end
+      
+      return a
+    end
+  
+    # obtiene cantidad de registros en cola para incrawl.lnsearchvariation
+    def getPendingLnSearchVariationBlockInCrawlCount()
+      return DB.from(:lnsearchvariationblock).where(:incrawl_reservation_id=>self.id, :incrawl_start_time=>nil).count
+    end
+  
+  end # class Worker
+  
+end # module BlackStack