nera 0.1.2 → 0.2.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.2.0
+* 1 major enhancement:
+  * logger is implemented. Log informatios are stored in "db_name"/Tables/logfile.txt.
+* 2 bug fixes
+  * updated_at records of tables have been correctly implemented.
+
 == 0.1.2
 * 1 major enhancement:
   * constructor of ParamLayerController now accepts String type simulator name.

data/lib/nera/nera_database.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 require 'yaml'
-#require 'filelock'
 require 'pstore'
+require 'observer'
 require 'pp'
 
 #* list of public methods
@@ -73,15 +73,24 @@ module NERA
     # classes of values
     VALUE_CLASSES = [ String, Symbol, Integer, Float, Date, DateTime, TrueClass, FalseClass, NilClass ]
 
+    # notify to updates to observer
+    include Observable
+    
     public
     # ----------------------------------
-    def initialize( path_to_file )
+    def initialize( path_to_file, notify_observer_arg = nil )
       @filename = path_to_file
       @in_transaction = nil
+      @notify_observer_arg = notify_observer_arg
       unless File.exist?(@filename)
         raise "No such database : #{@filename}"
       end
     end
+
+    # ------------------------------------
+    def set_yaml_file( yml_path)
+      @yml_path = yml_path.to_s
+    end
     
     # ------------------------------------
     def transaction
@@ -94,6 +103,18 @@ module NERA
         begin
           @in_transaction = true
           yield
+          if @notify_observer_arg
+            notify_observers( @notify_observer_arg)
+          else
+            notify_observers
+          end
+          if @yml_path
+            File.open( @yml_path,'w') do |io|
+              l = find_all do |r| true end
+              YAML.dump( l, io)
+              io.flush
+            end
+          end
         ensure
           @in_transaction = false
           nil
@@ -140,6 +161,7 @@ module NERA
         new_rec[:id] = new_id
         @pstore[:max_id] = new_id
         @pstore[new_id] = new_rec
+        changed
       end
       return new_id
     end
@@ -235,6 +257,7 @@ module NERA
         end
         @pstore[id_to_update] = rec
         flag = true
+        changed
       end
       return flag
     end
@@ -267,6 +290,7 @@ module NERA
         stat = nil
         transaction do
           stat = @pstore.delete(ids)
+          changed
         end
         return stat
       else

data/lib/nera/nera_db_folders.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'nera_simulator_records'
 require 'nera_job_records'
+require 'logger'
 
 
 module NERA
@@ -8,6 +9,14 @@ module NERA
   # This class contains the information of the folder structure
   class DbFolders
 
+    # -------------------------------------
+    # instance variables ------------------
+    # -------------------------------------
+    @db_folder  # path to db_folder
+    @logger     # logger instance
+
+    attr_reader :logger
+
     #--------------------------------------
     #-class methods -----------------------
     #--------------------------------------
@@ -26,6 +35,10 @@ module NERA
       Dir.glob( "#{@db_folder}/Simulator_classes/*.rb").each do |lib|
         require lib
       end
+
+      # logger instance
+      @logger = Logger.new( "#{@db_folder}/Tables/logfile.txt", 8)
+      @logger.level = Logger::INFO
     end
 
     def valid_db?( fold)

data/lib/nera/nera_job_layer_controller.rb

@@ -22,6 +22,7 @@ module NERA
       
       @db_folders = NERA::DbFolders.new( path_db_folder)
       @job_records = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
+      @job_records.set_yaml_file( @db_folders.path_to_jobs_yaml)
     end
 
     public
@@ -63,22 +64,29 @@ module NERA
           d = @job_records.destroy( jid)
           next unless d
           sim_recs = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
-          klass = eval( d[:simulator])
+          sim_recs.set_yaml_file( @db_folders.path_to_simulators_yaml )
+          found = sim_recs.list.find do |item| item[:name] == d[:simulator] end
+          sim_id = found[:id]
+          klass = NERA::Simulator.inherited_simulators.find do |sim|
+            sim.to_s == d[:simulator]
+          end
           raise RuntimeError, "must not happen" unless klass
-          run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( klass, d[:parameter_id]) )
+          p_tab_path = @db_folders.path_to_parameters_table( klass)
+          param_recs = NERA::ParameterRecords.new( p_tab_path, sim_recs, sim_id)
+          param_recs.set_yaml_file( @db_folders.path_to_parameters_yaml( klass) )
+          run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( klass, d[:parameter_id]), param_recs, d[:parameter_id] )
+          run_records.set_yaml_file( @db_folders.path_to_runs_yaml( klass, d[:parameter_id]) )
           run_records.transaction {
             a = run_records.destroy_job_id( jid)
             raise RuntimeError, "must not happen" unless a
             FileUtils.rm( @db_folders.path_to_job_script(jid) )
           }
-          File.open( @db_folders.path_to_runs_yaml( klass, d[:parameter_id]), 'w') do |io|
-            YAML.dump( run_records.list_all, io)
-            io.flush
-          end
           destroyed_jobids << jid
+          @db_folders.logger.info(self.class.to_s) {
+            "canceled a job (jobid:#{jid})"
+          }
         end
       }
-      dump_in_yaml
       destroyed_jobids = nil if destroyed_jobids.size == 0
       return destroyed_jobids
     end
@@ -96,19 +104,18 @@ module NERA
         fpath = @db_folders.path_to_include_layer + filename
         return nil unless File.exist?(fpath)
         jinfo, rinfo = expand_and_parse( fpath)
-        run_layer_path, run_recs, run_yaml_path = check_consistency( jinfo, rinfo)
+        run_layer_path, run_recs = check_consistency( jinfo, rinfo)
         run_recs.transaction {
           folder_path = fpath.sub(/.tar.bz2$/,'/')
           file_move( folder_path, run_layer_path, jinfo[:run_ids])
           update_tables( run_recs, jinfo, rinfo)
         }
         remove_files( fpath)
-        File.open( run_yaml_path, 'w') do |io|
-          YAML.dump( run_recs.list_all, io)
-          io.flush
-        end
+        @db_folders.logger.info(self.class.to_s) {
+          "included a file (#{filename})"
+        }
+
       }
-      dump_in_yaml
       return true
     end
 
@@ -139,12 +146,17 @@ module NERA
       # check consistency of the simulator
       conflicting unless jinfo[:simulator] == found[:simulator]
       sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
-      sim_class = eval( jinfo[:simulator])
+      sim_records.set_yaml_file( @db_folders.path_to_simulators_yaml )
+      sim_class = NERA::Simulator.inherited_simulators.find do |sim|
+        sim.to_s == jinfo[:simulator]
+      end
       conflicting unless jinfo[:simulator] == sim_class.to_s
       
       # check consistency of the parameter
       conflicting unless jinfo[:param_id] == found[:parameter_id]
-      param_records = NERA::ParameterRecords.new( @db_folders.path_to_parameters_table( sim_class) , sim_class)
+      f1 = sim_records.list.find do |item| item[:name] == jinfo[:simulator] end
+      param_records = NERA::ParameterRecords.new( @db_folders.path_to_parameters_table( sim_class) , sim_records, f1[:id] )
+      param_records.set_yaml_file( @db_folders.path_to_parameters_yaml( sim_class) )
       param = param_records.find_by_id( jinfo[:param_id])
       jinfo[:parameters].each_pair do |key, value|
         conflicting unless param[key] == value
@@ -153,8 +165,8 @@ module NERA
       # check consistency of the runs
       conflicting unless jinfo[:run_ids][0] == found[:run_id]
       conflicting unless jinfo[:run_ids].size == found[:number_of_runs]
-      run_recs = NERA::RunRecords.new( @db_folders.path_to_runs_table( sim_class, jinfo[:param_id]) )
-      run_yaml_path = @db_folders.path_to_runs_yaml( sim_class, jinfo[:param_id])
+      run_recs = NERA::RunRecords.new( @db_folders.path_to_runs_table( sim_class, jinfo[:param_id]), param_records, jinfo[:param_id])
+      run_recs.set_yaml_file( @db_folders.path_to_runs_yaml( sim_class, jinfo[:param_id]) )
       found_runs = run_recs.list_all_not_finished.find_all do |rec|
         rec[:job_id] == jinfo[:job_id] and jinfo[:run_ids].include?(rec[:id])
       end
@@ -164,7 +176,7 @@ module NERA
       raise "Run info is not consistent with job info!" unless jinfo[:run_ids] == rinfo.keys.sort
       
       run_layer_path = @db_folders.path_to_run_layer( sim_class, jinfo[:param_id])
-      return run_layer_path, run_recs, run_yaml_path
+      return run_layer_path, run_recs
     end
 
     def conflicting
@@ -223,16 +235,8 @@ module NERA
         f = include(fname)
         flag = nil unless f
       end
-      dump_in_yaml
       return flag
     end
 
-    def dump_in_yaml
-      File.open( @db_folders.path_to_jobs_yaml, 'w') do |io|
-        YAML.dump( @job_records.list_all, io)
-        io.flush
-      end
-    end
-
   end
 end

data/lib/nera/nera_job_records.rb

@@ -25,6 +25,11 @@ module NERA
       @db = NERA::Database.new( db_file)
     end
 
+    # argument is the path to jobs.yml
+    def set_yaml_file( yaml_path)
+      @db.set_yaml_file( yaml_path)
+    end
+
     # if file already exists, returns false
     def self.create_table( db_file)
       NERA::Database.create_table( db_file)

data/lib/nera/nera_parameter_layer_controller.rb

@@ -20,17 +20,21 @@ module NERA
       raise ArgumentError unless path_db_folder.is_a?(String)
       @db_folders = NERA::DbFolders.new( path_db_folder)
       sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+      sim_records.set_yaml_file( @db_folders.path_to_simulators_yaml )
+      
       found = sim_records.list.find do |rec|
         rec[:name] == sim_name.to_s
       end
       raise "No such simulator." unless found
+      sim_id = found[:id]
       @sim_class = NERA::Simulator.inherited_simulators.find do |sim|
         sim.to_s == sim_name.to_s
       end
       raise "No such simulator." unless @sim_class
       
       p_tab_path = @db_folders.path_to_parameters_table( @sim_class)
-      @param_records = NERA::ParameterRecords.new( p_tab_path, @sim_class)
+      @param_records = NERA::ParameterRecords.new( p_tab_path, sim_records, sim_id)
+      @param_records.set_yaml_file( @db_folders.path_to_parameters_yaml( @sim_class) )
     end
 
     def parameters_list_in_csv
@@ -73,22 +77,24 @@ module NERA
         pid = @param_records.add( p_hash)
         return nil unless pid
         b = @db_folders.create_new_parameter_folder( @sim_class, pid)
-        raise "Creation of a new folder for #{kalss}, #{pid} failed." unless b
+        raise "Creation of a new folder for #{@sim_calss}, #{pid} failed." unless b
         path = @db_folders.path_to_runs_table( @sim_class, pid)
         c = NERA::RunRecords.create_table( path)
         raise "File #{path} already exists." unless c
+        @db_folders.logger.info(self.class.to_s) {
+          "created a new parameter set (#{@sim_class.to_s}/#{pid})"
+        }
       }
-      dump_in_yaml
       return pid
     end
 
     def move_a_parameter_set_into_trashbox( id)
       return nil unless @param_records.find_by_id(id)
-      run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( @sim_class, id) )
+      run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( @sim_class, id), @param_records, id )
       return nil if run_records.list_all_not_finished.size > 0
 
       job_records = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
-      job_records.transaction {
+      job_records.transaction { # to lock the runs tables
         @param_records.transaction {
           flag = @param_records.update_to_state_trashbox(id)
           return nil unless flag
@@ -97,9 +103,11 @@ module NERA
           system(cmd)
           raise "Command #{cmd} failed" unless $? == 0
           FileUtils.rm_r(r_path)
+          @db_folders.logger.info(self.class.to_s) {
+            "moved a parameter set into the trashbox (#{@sim_class.to_s}/#{id})"
+          }
         }
       }
-      dump_in_yaml
       return true
     end
 
@@ -134,8 +142,10 @@ module NERA
         system(cmd)
         raise "Command #{cmd} failed" unless $? == 0
         FileUtils.rm(r_path+".tar.bz2")
+        @db_folders.logger.info(self.class.to_s) {
+          "reverted a parameter set in the trashbox (#{@sim_class.to_s}/#{id})"
+        }
       }
-      dump_in_yaml
       return true
     end
 
@@ -145,17 +155,12 @@ module NERA
         return nil unless flag
         r_path = @db_folders.path_to_run_layer( @sim_class, id).sub(/\/$/,'')
         FileUtils.rm("#{r_path}.tar.bz2")
+        @db_folders.logger.info(self.class.to_s) {
+          "deleted a parameter set in the trashbox (#{@sim_class.to_s}/#{id})"
+        }
       }
-      dump_in_yaml
       return true
     end
 
-    def dump_in_yaml
-      File.open( @db_folders.path_to_parameters_yaml( @sim_class), 'w') do |io|
-        YAML.dump( @param_records.list_all, io)
-        io.flush
-      end
-    end
-
   end
 end

data/lib/nera/nera_parameter_records.rb

@@ -21,13 +21,17 @@ module NERA
 
     # simulator_specific keys
     @sim_class
-    
+
     # argument is the path to database file
-    def initialize( db_file, sim_class)
-      unless sim_class.superclass == NERA::Simulator
-        raise ArgumentError, "Given simulator class is not a subclass of NERA::Simulator : #{sim_class}"
+    def initialize( db_file, sim_records, sim_id)
+      unless sim_records.is_a?( NERA::SimulatorRecords)
+        raise ArgumentError, "The second argument must be an instance of NERA::SimualtorRecords. #{sim_records.inspect}"
       end
-      @sim_class = sim_class
+      unless sim_id.is_a?(Integer)
+        raise ArgumentError, "sim_id must be an Integer. : #{sim_id.inspect}"
+      end
+      
+      @sim_class = sim_records.get_class( sim_id)
       @keys = ATTRIBUTES_PART.map do |k|
         k[0]
       end
@@ -41,7 +45,13 @@ module NERA
         raise ArgumentError, "Invalid class. This class has a parameter : #{found}"
       end
       @keys += sim_keys
-      @db = NERA::Database.new( db_file)
+      @db = NERA::Database.new( db_file, sim_id)
+      @db.add_observer( sim_records)
+    end
+
+    # argument is the path to parameters.yml
+    def set_yaml_file( yaml_path)
+      @db.set_yaml_file( yaml_path)
     end
 
     # if file already exists, return false
@@ -169,6 +179,8 @@ module NERA
       @db.update( found)
     end
 
+    alias :update :touch
+
     def destroy( id)
       raise ArgumentError unless id.is_a?(Integer)
       found = @db.find_by_id( id)

data/lib/nera/nera_remote_connector.rb

@@ -77,17 +77,21 @@ module NERA
         Net::SSH.start( found[:host_url], found[:user], h) do |ssh|
           str = ssh.exec!( cmd)
         end
-      rescue Errno::ECONNREFUSED
+      rescue Errno::ECONNREFUSED => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Errno::ENETUNREACH
+      rescue Errno::ENETUNREACH => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Net::SSH::Exception
+      rescue SocketError => ex
         $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue SocketError
+      rescue Net::SSH::Exception => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
       end
       $stderr.puts "done"
@@ -131,20 +135,27 @@ module NERA
                 sftp.file.open(target_path, "w") do |f| f.puts contents end
                 ssh.exec!("chmod +x #{target_path}")
                 @job_records.update_to_state_copied( jid, host[:name])
+                @db_folders.logger.info(self.class.to_s) {
+                  "transfered a file (#{File.basename(pjs)}) to #{host[:name]}"
+                }
               end
             end
           end
-        rescue Errno::ECONNREFUSED
+        rescue Errno::ECONNREFUSED => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue Errno::ENETUNREACH
+        rescue Errno::ENETUNREACH => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue SocketError
+        rescue SocketError => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue Net::SSH::Exception
+        rescue Net::SSH::Exception => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
         end
         $stderr.puts "done"
@@ -199,20 +210,27 @@ module NERA
                 @job_records.update_to_state_copied( jid, host[:name])
                 ssh.exec!("cd #{target_dir} && #{host[:submission_command]} #{target_path} &")
                 @job_records.update_to_state_submitted( jid, host[:name])
+                @db_folders.logger.info(self.class.to_s) {
+                  "submitted a file (#{File.basename(pjs)}) to #{host[:name]}"
+                }
               end
             end
           end
-        rescue Errno::ECONNREFUSED
+        rescue Errno::ECONNREFUSED => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue Errno::ENETUNREACH
+        rescue Errno::ENETUNREACH => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue SocketError
+        rescue SocketError => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
-        rescue Net::SSH::Exception
+        rescue Net::SSH::Exception => ex
           $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
           return :connection_failed
         end
         $stderr.puts "done"
@@ -235,17 +253,21 @@ module NERA
         Net::SSH.start( host[:host_url], host[:user], h) do |ssh|
           ls_str = ssh.exec!("ls #{host[:job_path]}")
         end
-      rescue Errno::ECONNREFUSED
+      rescue Errno::ECONNREFUSED => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Errno::ENETUNREACH
+      rescue Errno::ENETUNREACH => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue SocketError
+      rescue SocketError => ex
         $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Net::SSH::Exception
+      rescue Net::SSH::Exception => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
       end
       $stderr.puts "done"
@@ -312,20 +334,28 @@ module NERA
               $stderr.print "  deleting #{sh_file}.....\t"
               sftp.remove!(target_dir + '/' + sh_file)
               $stderr.puts "done"
+              
+              @db_folders.logger.info(self.class.to_s) {
+                "downloaded a data file (#{d_file}) from #{host[:name]}"
+              }
             end
           end
         end
-      rescue Errno::ECONNREFUSED
+      rescue Errno::ECONNREFUSED => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Errno::ENETUNREACH
+      rescue Errno::ENETUNREACH => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue SocketError
+      rescue SocketError => ex
         $stderr.puts "failed"
+          @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
-      rescue Net::SSH::Exception
+      rescue Net::SSH::Exception => ex
         $stderr.puts "failed"
+        @db_folders.logger.error(self.class.to_s) { ex.to_s }
         return :connection_failed
       end
       $stderr.puts "done"

data/lib/nera/nera_run_layer_controller.rb

@@ -25,10 +25,13 @@ module NERA
 
       @db_folders = NERA::DbFolders.new( path_db_folder)
       sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+      sim_records.set_yaml_file( @db_folders.path_to_simulators_yaml )
+      
       found = sim_records.list.find do |rec|
         rec[:name] == sim_name.to_s
       end
       raise "No such simulator : #{sim_name.to_s}" unless found
+      sim_id = found[:id]
       sim_class = NERA::Simulator.inherited_simulators.find do |sim|
         sim.to_s == sim_name.to_s
       end
@@ -36,7 +39,8 @@ module NERA
       
       @sim_instance = sim_class.new
       @param_id = param_id
-      param_records = NERA::ParameterRecords.new( @db_folders.path_to_parameters_table( sim_class), sim_class)
+      param_records = NERA::ParameterRecords.new( @db_folders.path_to_parameters_table( sim_class), sim_records, sim_id)
+      param_records.set_yaml_file( @db_folders.path_to_parameters_yaml( sim_class) )
       found = param_records.find_by_id( @param_id)
       raise "No such parameter : #{param_id}." unless found
       @sim_instance.class::Parameters.each do |pa|
@@ -48,7 +52,8 @@ module NERA
         end
       end
       
-      @run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( sim_class, @param_id) )
+      @run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( sim_class, @param_id), param_records, @param_id )
+      @run_records.set_yaml_file( @db_folders.path_to_runs_yaml( @sim_instance.class, @param_id) )
     end
     
     def path_to_run_layer
@@ -80,6 +85,7 @@ module NERA
 
       job_ids = []
       job_recs = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
+      job_recs.set_yaml_file( @db_folders.path_to_jobs_yaml)
       js = NERA::JobScript.new( @db_folders)
       job_recs.transaction {
         @run_records.transaction {
@@ -89,13 +95,16 @@ module NERA
             jid = job_recs.add( @sim_instance.class, @param_id, rid, num_runs_per_job)
             @run_records.set_job_id( rid, num_runs_per_job, jid)
             sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+            sim_records.set_yaml_file( @db_folders.path_to_simulators_yaml )
             found = sim_records.list.find do |rec| rec[:name] == @sim_instance.class.to_s end
             path_script = js.create_script( jid, found[:id], @param_id, @sim_instance, run_stat)
             job_ids << jid
+            @db_folders.logger.info(self.class.to_s) {
+              "created a job (#{@sim_instance.class.to_s}/#{@param_id}/#{rid}, #{num_runs_per_job} runs, jobid:#{jid})"
+            }
           end
         }
       }
-      dump_in_yaml( job_recs)
       return job_ids
     end
 
@@ -132,6 +141,7 @@ module NERA
       end
       
       job_recs = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
+      job_recs.set_yaml_file( @db_folders.path_to_jobs_yaml)
       destroyed_jobids = []
       job_recs.transaction {
         @run_records.transaction {
@@ -142,10 +152,12 @@ module NERA
             raise "must not happen" unless a
             FileUtils.rm( @db_folders.path_to_job_script(jid) )
             destroyed_jobids << jid
+            @db_folders.logger.info(self.class.to_s) {
+              "canceled a job (jobid:#{jid})"
+            }
           end
         }
       }
-      dump_in_yaml( job_recs)
       destroyed_jobids = nil if destroyed_jobids.size == 0
       return destroyed_jobids
     end
@@ -172,6 +184,10 @@ module NERA
       FileUtils.cd( @db_folders.path_to_run_layer(@sim_instance.class, @param_id) ) {
         @sim_instance.__send__( method_str)
       }
+      @db_folders.logger.info(self.class.to_s) {
+        "#{method_str} (#{@sim_instance.class.to_s}/#{@param_id})"
+      }
+
     end
 
     def analyze_all
@@ -180,24 +196,18 @@ module NERA
       end
       return nil unless found
 
+      found.each do |meth|
+        analyze( meth)
+      end
+    end
+=begin
       FileUtils.cd( @db_folders.path_to_run_layer(@sim_instance.class, @param_id) ) {
         found.each do |meth|
           @sim_instance.__send__( meth)
         end
       }
     end
-
-    private
-    def dump_in_yaml( job_recs)
-      File.open( @db_folders.path_to_runs_yaml( @sim_instance.class, @param_id), 'w') do |io|
-        YAML.dump( @run_records.list_all, io)
-        io.flush
-      end
-      File.open( @db_folders.path_to_jobs_yaml, 'w') do |io|
-        YAML.dump( job_recs.list_all, io)
-        io.flush
-      end
-    end
+=end
 
   end
 end