flor 0.9.2 → 0.9.3

data/lib/flor/unit/models/execution.rb

@@ -57,12 +57,12 @@ module Flor
 
     def self.by_tag(name)
 
-      exids = self.db[:flor_pointers]
+      _exids = self.db[:flor_pointers]
         .where(type: 'tag', name: name, value: nil)
         .select(:exid)
         .distinct
 
-      self.where(status: 'active', exid: exids)
+      self.where(status: 'active', exid: _exids)
     end
 
     def self.by_var(name, value=:no)
@@ -77,12 +77,12 @@ module Flor
         w[:value] = value.to_s
       end
 
-      exids = self.db[:flor_pointers]
+      _exids = self.db[:flor_pointers]
         .where(w)
         .select(:exid)
         .distinct
 
-      self.where(status: 'active', exid: exids)
+      self.where(status: 'active', exid: _exids)
     end
 
     def self.by_tasker(name, taskname=:no)
@@ -90,12 +90,12 @@ module Flor
       w = { type: 'tasker', name: name }
       w[:value] = taskname if taskname != :no
 
-      exids = self.db[:flor_pointers]
+      _exids = self.db[:flor_pointers]
         .where(w)
         .select(:exid)
         .distinct
 
-      self.where(status: 'active', exid: exids)
+      self.where(status: 'active', exid: _exids)
     end
 
 #    def self.by_task(name)

data/lib/flor/unit/scheduler.rb

@@ -28,7 +28,9 @@ module Flor
   class Scheduler
 
     attr_reader :conf, :env
-    attr_reader :hooker, :storage, :loader, :tasker
+
+    attr_reader :hooker, :storage, :loader, :ganger
+    attr_reader :logger
 
     attr_reader :thread_status
 
@@ -55,10 +57,13 @@ module Flor
         (Flor::Conf.get_class(@conf, 'storage') || Flor::Storage).new(self)
       @loader =
         (Flor::Conf.get_class(@conf, 'loader') || Flor::Loader).new(self)
-      @tasker =
-        (Flor::Conf.get_class(@conf, 'tasker') || Flor::Tasker).new(self)
+      @ganger =
+        (Flor::Conf.get_class(@conf, 'ganger') || Flor::Ganger).new(self)
+
+      @logger =
+        (Flor::Conf.get_class(@conf, 'logger') || Flor::Logger).new(self)
 
-      @hooker.add('logger', Flor::Logger)
+      @hooker.add('logger', @logger)
       @hooker.add('wlist', Flor::WaitList)
 
       @heart_rate = @conf[:sch_heart_rate] || 0.3
@@ -89,6 +94,11 @@ module Flor
       @identifier ||= 's' + Digest::MD5.hexdigest(self.object_id.to_s)[0, 5]
     end
 
+    def has_tasker?(exid, tname)
+
+      @ganger.has_tasker?(exid, tname)
+    end
+
     def shutdown
 
       @thread_status = :shutdown
@@ -98,7 +108,7 @@ module Flor
 
       @hooker.shutdown
       @storage.shutdown
-      @tasker.shutdown
+      @ganger.shutdown
     end
 
     def hook(*args, &block)
@@ -226,12 +236,12 @@ module Flor
 
       unit = opts[:unit] || @conf['unit'] || 'u0'
 
-      Flor.print_src(source, opts) if @conf['log_src']
+      @logger.log_src(source, opts)
 
       exid = Flor.generate_exid(domain, unit)
       msg = Flor.make_launch_msg(exid, source, opts)
 
-      Flor.print_tree(msg['tree']) if @conf['log_tree']
+      @logger.log_tree(msg['tree'])
 
       return [ msg, opts ] if opts[:nolaunch]
         # for testing purposes
@@ -316,19 +326,19 @@ module Flor
       (@archive[exid] ||= {})[n['nid']] = Flor.dup(n) if @archive
     end
 
-#    # Given an exid, returns the execution, if currently executing.
-#    #
-#    def execution(exid)
-#
-#      ex = @executors.find { |x| x.exid == exid }
-#      ex ? ex.execution : nil
-#    end
-
     def executor(exid)
 
       @executors.find { |x| x.exid == exid }
     end
 
+    # Given an exid, returns the execution, if currently executing.
+    #
+    def execution(exid)
+
+      ex = executor(exid)
+      ex ? ex.execution : nil
+    end
+
     protected
 
 #    # return [ domain, tree ]

data/lib/flor/unit/storage.rb

@@ -72,17 +72,28 @@ module Flor
       db_version == migration_version
     end
 
-    def synchronize(sync=true, &block)
+    def synchronize(on=true, &block)
 
-      Thread.current[:sto_errored_items] = nil
+      Thread.current[:sto_errored_items] = nil if on
 
-      if @mutex && sync
+      if @mutex && on
         @mutex.synchronize(&block)
       else
         block.call
       end
     end
 
+    def transync(on=true, &block)
+
+      Thread.current[:sto_errored_items] = nil if on
+
+      if @mutex && on
+        @mutex.synchronize { @db.transaction(&block) }
+      else
+        block.call
+      end
+    end
+
     def migrate(to=nil, from=nil)
 
       dir =
@@ -110,13 +121,16 @@ module Flor
 
     def load_exids
 
-      @db[:flor_messages]
-        .select(:exid)
-        .where(status: 'created')
-        .order_by(:ctime)
-        .distinct
-        .all
-        .collect { |r| r[:exid] }
+      synchronize do
+
+        @db[:flor_messages]
+          .select(:exid)
+          .where(status: 'created')
+          .order_by(:ctime)
+          .distinct
+          .all
+          .collect { |r| r[:exid] }
+      end
 
     rescue => err
 
@@ -127,125 +141,125 @@ module Flor
 
     def load_execution(exid)
 
-      e = @db[:flor_executions]
-        .select(:id, :content)
-        .where(exid: exid) # status active or terminated doesn't matter
-        .first
+      synchronize do
+
+        e = @db[:flor_executions]
+          .select(:id, :content)
+          .where(exid: exid) # status active or terminated doesn't matter
+          .first
+
+        return {
+          'exid' => exid, 'nodes' => {}, 'errors' => [], 'tasks' => {},
+          'counters' => {}, 'start' => Flor.tstamp,
+          'size' => -1
+        } unless e
 
-      if e
         ex = from_blob(e[:content])
+
         fail("couldn't parse execution (db id #{e[:id]})") unless ex
+
         ex['id'] = e[:id]
         ex['size'] = e[:content].length
+
         ex
-      else
-        put_execution({
-          'exid' => exid, 'nodes' => {}, 'errors' => [], 'tasks' => {},
-          #'ashes' => {},
-          'counters' => {}, 'start' => Flor.tstamp,
-          'size' => -1
-        })
       end
     end
 
     def put_execution(ex)
 
-      if i = ex['id']
+      status =
+        if ex['nodes']['0'] && ex['nodes']['0']['removed']
+          'terminated'
+        else
+          'active'
+        end
 
-        status =
-          if ex['nodes']['0']['removed']
-            'terminated'
-          else
-            'active'
-          end
+      id = ex['id']
+
+      if id
 
         ex['end'] ||= Flor.tstamp \
           if status == 'terminated'
         ex['duration'] = Time.parse(ex['end']) - Time.parse(ex['start']) \
           if ex['end']
+      end
 
-        data = to_blob(ex)
-        ex['size'] = data.length
+      data = to_blob(ex)
+      ex['size'] = data.length
 
-        synchronize do
+      transync do
 
-          @db.transaction do
+        now = Flor.tstamp
 
-            now = Flor.tstamp
+        if id
 
+          @db[:flor_executions]
+            .where(id: id)
+            .update(
+              content: data,
+              status: status,
+              mtime: now)
+
+        else
+
+          ex['id'] =
             @db[:flor_executions]
-              .where(id: i)
-              .update(
+              .insert(
+                domain: Flor.domain(ex['exid']),
+                exid: ex['exid'],
                 content: data,
-                status: status,
+                status: 'active',
+                ctime: now,
                 mtime: now)
-
-            remove_nodes(ex, status, now)
-            update_pointers(ex, status, now)
-          end
         end
-      else
-
-        data = to_blob(ex)
-        ex['size'] = data.length
-
-        synchronize do
-
-          @db.transaction do
 
-            now = Flor.tstamp
-
-            ex['id'] =
-              @db[:flor_executions]
-                .insert(
-                  domain: Flor.domain(ex['exid']),
-                  exid: ex['exid'],
-                  content: data,
-                  status: 'active',
-                  ctime: now,
-                  mtime: now)
-
-            remove_nodes(ex, status, now)
-            update_pointers(ex, status, now)
-          end
-        end
+        remove_nodes(ex, status, now)
+        update_pointers(ex, status, now)
       end
 
       ex
 
     rescue => err
+
       Thread.current[:sto_errored_items] = [ ex ]
       raise err
     end
 
     def fetch_messages(exid)
 
-      synchronize do
-        @db.transaction do
+      transync do
 
-          ms = @db[:flor_messages]
-            .select(:id, :content)
-            .where(status: 'created', exid: exid)
-            .order_by(:id)
-            .map { |m| r = from_blob(m[:content]) || {}; r['mid'] = m[:id]; r }
+        ms = @db[:flor_messages]
+          .select(:id, :content)
+          .where(status: 'created', exid: exid)
+          .order_by(:id)
+          .map { |m| r = from_blob(m[:content]) || {}; r['mid'] = m[:id]; r }
 
-          @db[:flor_messages]
-            .where(id: ms.collect { |m| m['mid'] })
-            .update(status: 'loaded')
-               #
-               # flag them as "loaded" so that other scheduler don't pick them
+        @db[:flor_messages]
+          .where(id: ms.collect { |m| m['mid'] })
+          .update(status: 'loaded')
+             #
+             # flag them as "loaded" so that other scheduler don't pick them
 
-          ms
-        end
+        ms
       end
+
+    rescue => err
+
+      @unit.logger.warn("#{self.class}#fetch_messages()", err, '(returning [])')
+
+      []
     end
 
     def fetch_traps(exid)
 
-      traps
-        .where(status: 'active')
-        .where(domain: split_domain(exid))
-        .all
+      synchronize do
+
+        traps
+          .where(status: 'active')
+          .where(domain: split_domain(exid))
+          .all
+      end
 
     rescue => err
 
@@ -257,6 +271,7 @@ module Flor
     def consume(messages)
 
       synchronize do
+
         if @archive
           @db[:flor_messages]
             .where(id: messages.collect { |m| m['mid'] }.compact)
@@ -269,17 +284,21 @@ module Flor
       end
 
     rescue => err
+
       Thread.current[:sto_errored_items] = messages
       raise err
     end
 
     def load_timers
 
-      timers
-        .select(:id, :content)
-        .where(status: 'active')
-        .order_by(:id)
-        .all
+      synchronize do
+
+        timers
+          .select(:id, :content)
+          .where(status: 'active')
+          .order_by(:id)
+          .all
+      end
 
     rescue => err
 
@@ -345,6 +364,7 @@ module Flor
       @unit.timers[id]
 
     rescue => err
+
       Thread.current[:sto_errored_items] = [ message ]
       raise err
     end
@@ -355,44 +375,43 @@ module Flor
 
       r = nil
 
-      synchronize do
-        @db.transaction do
+      transync do
 
 # TODO: cron/every stop conditions maybe?
 
-          if timer.type != 'at' && timer.type != 'in'
-
-            @db[:flor_timers]
-              .where(id: timer.id)
-              .update(
-                count: timer.count + 1,
-                ntime: compute_next_time(timer.type, timer.schedule),
-                mtime: Flor.tstamp)
-            r = timers[timer.id]
+        if timer.type != 'at' && timer.type != 'in'
 
-          elsif @archive
+          @db[:flor_timers]
+            .where(id: timer.id)
+            .update(
+              count: timer.count + 1,
+              ntime: compute_next_time(timer.type, timer.schedule),
+              mtime: Flor.tstamp)
+          r = timers[timer.id]
 
-            @db[:flor_timers]
-              .where(id: timer.id)
-              .update(
-                count: timer.count + 1,
-                status: 'triggered',
-                mtime: Flor.tstamp)
+        elsif @archive
 
-          else
+          @db[:flor_timers]
+            .where(id: timer.id)
+            .update(
+              count: timer.count + 1,
+              status: 'triggered',
+              mtime: Flor.tstamp)
 
-            @db[:flor_timers]
-              .where(id: timer.id)
-              .delete
-          end
+        else
 
-          put_messages([ timer.to_trigger_message ], false)
+          @db[:flor_timers]
+            .where(id: timer.id)
+            .delete
         end
+
+        put_messages([ timer.to_trigger_message ], false)
       end
 
       r
 
     rescue => err
+
       Thread.current[:sto_errored_items] = [ timer ]
       raise err
     end
@@ -404,29 +423,28 @@ module Flor
       now = Flor.tstamp
 
       id =
-        synchronize do
-          @db.transaction do
-
-            @db[:flor_traps].insert(
-              domain: dom,
-              exid: exid,
-              nid: tra['bnid'],
-              onid: node['nid'],
-              trange: tra['range'],
-              tpoints: tra['points'],
-              ttags: tra['tags'],
-              theats: tra['heats'],
-              theaps: tra['heaps'],
-              content: to_blob(tra),
-              status: 'active',
-              ctime: now,
-              mtime: now)
-          end
+        transync do
+
+          @db[:flor_traps].insert(
+            domain: dom,
+            exid: exid,
+            nid: tra['bnid'],
+            onid: node['nid'],
+            trange: tra['range'],
+            tpoints: tra['points'],
+            ttags: tra['tags'],
+            theats: tra['heats'],
+            theaps: tra['heaps'],
+            content: to_blob(tra),
+            status: 'active',
+            ctime: now,
+            mtime: now)
         end
 
       traps[id]
 
     rescue => err
+
       Thread.current[:sto_errored_items] = [ node, tra ]
       raise err
     end