Class: NERA::CUI_exec

Inherits:

Object

• Object
• NERA::CUI_exec

Defined in:

lib/nera/nera_cui.rb

Instance Method Summary

• #initialize(path_db_folder) ⇒ CUI_exec constructor

  — main method.

• #job_layer_action ⇒ Object

  — action at job layer.

• #param_layer_action ⇒ Object

  — selection of a parameter set.

• #parameter_layer_menu_select ⇒ Object

  — menu at a parameter layer.

• #run_layer_action ⇒ Object

  — action at run layer.

• #sim_layer_action ⇒ Object

  — action at simulator layer.

Constructor Details

#initialize(path_db_folder) ⇒ CUI_exec

— main method

# File 'lib/nera/nera_cui.rb', line 37

def initialize( path_db_folder)
  @state = :simulator_layer
  @path_db_folder = path_db_folder
  unless FileTest.directory?(@path_db_folder)
    NERA::DbFolders.create_db(@path_db_folder)
  end
  
  while true
    case @state
    when :simulator_layer
      @state = sim_layer_action
    when :parameter_layer
      @state = param_layer_action
    when :run_layer
      @state = run_layer_action
    when :job_layer
      @state = job_layer_action
    when :exit
      return 0
    else
      raise "Must not happen"
    end
  end
end

Instance Method Details

#job_layer_action ⇒ Object

— action at job layer

# File 'lib/nera/nera_cui.rb', line 381

def job_layer_action
  $stdout.puts <<"HEADER"
===============================================
--- in job layer ------------------------------
  #{@path_db_folder} / Jobs
===============================================
HEADER

  action_list = ["Back to simulator layer",
                 "Show job infos",
                 "Cancel jobs",
                 "Execute jobs now",
                 "Show host infos",
                 "Upload jobs",
                 "Download data",
                 "Include data",
                 "Exit"]
  jlc = NERA::JobLayerController.new( @path_db_folder)
  rc = NERA::RemoteConnector.new( @path_db_folder)

  selected = 0
  Dir.chdir( jlc.path_to_job_layer) {
    selected = Dialog.select_one_or_return_string( action_list, "Select one")
    if selected.is_a?(String)
      system( selected)
      return :job_layer
    end
  }
  
  case action_list[selected]
  when "Back to simulator layer"
    return :simulator_layer
  when "Show job infos"
    Dir.chdir( jlc.path_to_job_layer) {
      system("less jobs.yml")
    }
    return :job_layer
  when "Cancel jobs"
    header,list = jlc.not_finished_list_in_csv
    list.unshift("Cancel")
    selected_jobs = Dialog::select_many( list, header).map do |num|
      list[num].split(',')[0].to_i
    end
    unless selected_jobs.include?(0)
      stat = jlc.cancel_jobs( selected_jobs)
      if stat
        str = selected_jobs.join(", ")
        Dialog::message("The following jobs are successfully cancelled.\n#{str}")
      else
        Dialog::message("Cancellation failed.")
      end
    end
    return :job_layer
  when "Execute jobs now"
    header,list = jlc.not_finished_list_in_csv
    list.unshift("Cancel")
    selected_jobs = Dialog::select_many( list, header).map do |num|
      list[num].split(',')[0].to_i
    end
    return :job_layer if selected_jobs.include?(0)

    system "top"
    if Dialog::ask("Will you execute now?", true)
      flag = jlc.execute_jobs_now( selected_jobs)
      Dialog::message("The following jobs are successfully submitted.\n#{flag.join(', ')}") if flag
      non_submitted = selected_jobs - flag.to_a
      Dialog::message("Warning! The following jobs are not submitted.\n#{non_submitted.join(', ')}") if non_submitted.size > 0
    end
    
    return :job_layer
  when "Show host infos"
    h_list = ["Cancel", "All"] + rc.hostnames
    sel = Dialog::select_many( h_list)
    if sel.include?(0)
      return :job_layer
    elsif sel.include?(1)
      rc.hostnames.each do |hname|
        Dialog::message("Information of the host #{hname} =========================")
        Dialog::message( rc.show_status( hname) )
      end
    else
      sel.each do |num|
        Dialog::message("Information of the host #{h_list[num]} =========================")
        Dialog::message( rc.show_status( h_list[num]) )
      end
    end
    return :job_layer
  when "Upload jobs"
    header,list = jlc.not_finished_list_in_csv
    list.unshift("Cancel")
    selected_jobs = Dialog::select_many( list, header).map do |num|
      list[num].split(',')[0].to_i
    end
    return :job_layer if selected_jobs.include?(0)

    h_list = ["Cancel"] + rc.hostnames
    sel = Dialog::select_one( h_list, "Select the host")
    return :job_layer if sel == 0
    selected_host = h_list[sel]
    
    Dialog::message("Information of the host #{selected_host} =========================")
    Dialog::message( rc.show_status( selected_host) + "\n" )
    if Dialog::ask("Will you upload the script?", true)
      if rc.submittable_hostnames.include?(selected_host) and Dialog::ask("Will you submit the jobs?", true)
        v = rc.submit( selected_jobs, selected_host)
        Dialog::message(v.to_s)
      else
        v = rc.transfer( selected_jobs, selected_host)
        Dialog::message(v.to_s)
      end
    end
    return :job_layer
  when "Download data"
    d_hash = rc.check_completion_all
    list = ["Cancel", "All"]
    d_hash.each_pair do |host, d_files|
      if d_files.is_a?(Array)
        d_files.each do |f|
          list << "#{f} @ #{host}"
        end
      end
    end
    sel = Dialog::select_many( list)
    if sel.include?(0)
      return :job_layer
    elsif sel.include?(1)
      d_hash.each_pair do |host, d_files|
        res = rc.download( d_files, host)
        if res.is_a?(Array)
          Dialog::message("#{res.join(', ')} have been downloaded.")
        else
          Dialog::message(res.to_s)
        end
      end
    else
      downloaded = []
      sel.each do |num|
        a = list[num].split('@')
        res = rc.download( [ a[0].strip ], a[1].strip)
        downloaded += res if res.is_a?(Array)
      end
      Dialog::message("#{downloaded.join(', ')} have been downloaded.")
    end
    return :job_layer
  when "Include data"
    list = jlc.include_list
    list = ["Cancel","All"] + list
    sel = Dialog::select_many( list)
    status = nil
    if sel.include?(0)
      return :job_layer
    elsif sel.include?(1)
      status = jlc.include_all
    else
      sel.each do |num|
        status = jlc.include( list[num])
      end
    end
    if status
      Dialog::message("Inclusion successfully completed.")
    else
      Dialog::message("Inclusion failed.")
    end
    return :job_layer
  when "Exit"
    return :exit
  end
end

#param_layer_action ⇒ Object

— selection of a parameter set

# File 'lib/nera/nera_cui.rb', line 134

def param_layer_action

  plc = NERA::ParameterLayerController.new( @path_db_folder, @simulator_class)
  unless plc
    Dialog::message("Specified simulator does not exist #{@path_db_folder}/#{@simulator_class}")
    return :simulator_layer
  end

  $stdout.puts <<"HEADER"
===============================================
--- in parameter layer ------------------------
  #{@path_db_folder} / #{@simulator_class}
===============================================
HEADER

  header,list = plc.parameters_list_in_csv
  list.unshift( "Menu")
  selected = 0
  Dir.chdir( plc.path_to_param_layer) {
    selected = Dialog::select_one_or_return_string( list, header)
    if selected.is_a?(String)
      system(selected)
      return :parameter_layer
    end
  }
  if selected == 0
    layer = parameter_layer_menu_select
    return layer
  else
    id = plc.get_id_from_csv_string( list[selected])
    @parameter_id = id
    return :run_layer
  end
end

#parameter_layer_menu_select ⇒ Object

— menu at a parameter layer

# File 'lib/nera/nera_cui.rb', line 170

def parameter_layer_menu_select
  menu = ["return to simulator layer",
          "create a new parameter set",
          "move a parameter set into the trashbox",
          "revert a parameter set in the trashbox",
          "delete a parameter set completely",
          "exit"]
  s = Dialog::select_one( menu, "Select one from the following")
  plc = NERA::ParameterLayerController.new( @path_db_folder, @simulator_class)
  case menu[s]
  when "return to simulator layer"
    return :simulator_layer
  when "create a new parameter set"
    plist = plc.list_of_parameters( @parameter_id)
    new_param_hash = Dialog::set_multiple_values( plist, "Input the new parameter set")
    f = plc.create_a_new_parameter_set( new_param_hash)
    if f
      Dialog::message("A new parameter is successfully added to the table.")
      @parameter_id = f
    else
      Dialog::message("This parameter already exists in the database.")
    end
    return :parameter_layer
  when "move a parameter set into the trashbox"
    header,list = plc.parameters_list_in_csv
    list.unshift("Cancel")
    s = Dialog::select_one( list, header)
    if s == 0
      return :parameter_layer
    else
      id = plc.get_id_from_csv_string( list[s])
      f = plc.move_a_parameter_set_into_trashbox(id)
      if f
        Dialog::message("Parameter #{id} was successfully moved into the trashbox")
      else
        Dialog::message("Couldn't move the parameter #{id} to the trashbox.\nYou have to cancel all the jobs that are not finished.")
      end
      return :parameter_layer
    end
  when "revert a parameter set in the trashbox"
    header,list = plc.trashbox_parameter_list_in_csv
    list.unshift("Cancel")
    s = Dialog::select_one( list, header)
    if s == 0
      return :parameter_layer
    else
      id = plc.get_id_from_csv_string( list[s])
      f = plc.revert_a_parameter_set_in_trashbox(id)
      if f
        Dialog::message("Parameter #{id} was successfully reverted.")
      else
        Dialog::message("Couldn't revert the parameter #{id}")
      end
      return :parameter_layer
    end
  when "delete a parameter set completely"
    header,list = plc.trashbox_parameter_list_in_csv
    list.unshift("Cancel")
    s = Dialog::select_one( list, header)
    if s == 0
      return :parameter_layer
    else
      id = plc.get_id_from_csv_string( list[s])
      f = plc.delete_a_parameter_set( id)
      if f
        Dialog::message("Parameter #{id} was successfully deleted.")
      else
        Dialog::message("Couldn't delete the parameter #{id}")
      end
      return :parameter_layer
    end
  when "exit"
    return :exit
  else
    raise "must not happen"
  end
end

#run_layer_action ⇒ Object

— action at run layer

# File 'lib/nera/nera_cui.rb', line 249

def run_layer_action

  rlc = NERA::RunLayerController.new( @path_db_folder, @simulator_class, @parameter_id)
  unless rlc
    Dialog::message("Table #{@path_db_folder}/#{@simulator_class}/#{@parameter_id} is not found.")
    return :parameter_layer
  end

  $stdout.puts <<"HEADER"
===============================================
--- in run layer ------------------------------
  #{@path_db_folder} / #{@simulator_class} / #{@parameter_id}
===============================================
HEADER

  action_list = ["Back to parameter layer",
                 "Show run infos",
                 "Create jobs",
                 #"Execute created jobs",
                 #"Submit created jobs to remote host",
                 "Cancel jobs",
                 "Analyze data",
                 "Exit"]
  selected = 0
  Dir.chdir( rlc.path_to_run_layer) {
    selected = Dialog::select_one_or_return_string( action_list, "Select one")
    if selected.is_a?(String)
      system( selected)
      return :run_layer
    end
  }
  
  case action_list[selected]
  when "Back to parameter layer"
    return :parameter_layer
  when "Show run infos"
    Dir.chdir( rlc.path_to_run_layer) {
      system("less runs.yml")
    }
    return :run_layer
  when "Create jobs"
    num_job = Dialog::get_integer( "Input the number of jobs (must be equal or larger than zero)") { |i| i >= 0 }
    return :run_layer if num_job == 0
    num_run_per_job = Dialog::get_integer( "Input the number of runs per job (must be larger than zero)") { |i| i > 0 }
    jobids = rlc.create_jobs( num_job, num_run_per_job)
    str = jobids.join(", ")
    Dialog::message( "The following jobs are newly created.\n#{str}")
    return :run_layer
  when "Execute created jobs"
=begin        
    header,list = rlc.not_finished_runs_list_in_csv
  list = RunLayerController::get_created_runs_list( @db_folder, @model_id, @parameter_id)
  selected = select_one( list, "Select a job to execute")
  job_id = list[selected][:job_id]
  stat = JobLayerController::execute_one( @db_folder, job_id)
  if stat
    $stderr.puts "Simulation finished successfully"
  else
    $stderr.puts "Simulation failed"
  end
=end
    return :run_layer
  when "Submit created jobs to remote host"
=begin        
    header,list = rlc.not_finished_runs_list_in_csv
    list.unshift("Cancel")
    selected_jobs = Dialog::select_many( list, header)
    unless selected_jobs.include?(0)
      rc = RemoteConnector.new( @db_folder)
      hosts = rc.hostnames
      hosts.unshift("Cancel")
      s = Dialog::select_one( hosts, "Select a host")
      return :run_layer if s == 0
      if rc.connect( hosts[s])
        Dialog::message( rc.get_status)
        action = Dialog::select_one( ["Transfer", "Transfer and Submit", "Cancel"], "Select action")
        stat = nil
        case action
        when 0
          stat = rc.transfer( selected_jobs)
          Dialog::message("File transfer to #{hosts[s]} failed") unless stat
        when 1
          stat = rc.submit( selected_jobs)
          Dialog::message("Submission to #{hosts[s]} failed") unless stat
        when 2
        end
        Dialog::message("Completed successfully.") if stat
      else
        Dialog::message("Connection to #{hosts[s]} failed.")
      end
    end
=end
    return :run_layer
  when "Cancel jobs"
    header,list = rlc.not_finished_jobs_list_in_csv
    list.unshift("Cancel")
    selected_jobs = Dialog::select_many( list, header).map do |num|
      list[num].split(',')[0].to_i
    end
    unless selected_jobs.include?(0)
      stat = rlc.cancel_jobs( selected_jobs)
      if stat
        str = selected_jobs.join(", ")
        Dialog::message("The following jobs are successfully cancelled.\n#{str}")
      else
        Dialog::message("Cancellation failed.")
      end
    end
    return :run_layer
  when "Analyze data"
    list = rlc.analysis_methods
    list = [ "Cancel", "All"] + list
    sel = Dialog.select_many( list, "Select numbers.")
    if sel.include?(0)
      return :run_layer
    elsif sel.include?(1)
      rlc.analyze_all
      return :run_layer
    else
      sel.each do |i|
        rlc.analyze( list[i])
      end
      return :run_layer
    end
  when "Exit"
    return :exit
  else
    raise "Must not happen"
  end
end

#sim_layer_action ⇒ Object

— action at simulator layer

# File 'lib/nera/nera_cui.rb', line 63

def sim_layer_action
  $stdout.puts <<"HEADER"
===============================================
--- in simulator layer ------------------------
  #{@path_db_folder} 
===============================================
HEADER
  
  slc = NERA::SimulatorLayerController.new(@path_db_folder)
  list = slc.list
  names = list.map do |r|
    r[:name]
  end
  names.unshift("go to Jobs layer")
  names += ["show logs", "remove a simulator", "dump a simulator", "import a simulator", "exit"]
  selected = 0
  Dir.chdir( slc.path_to_sim_layer) {
    selected = Dialog::select_one_or_return_string( names, "Select a simulator.")
    if selected.is_a?(String)
      system( selected)
      return :simulator_layer
    end
  }
  case names[selected]
  when "go to Jobs layer"
    return :job_layer
  when "show logs"
    system "less #{slc.path_to_log_file}"
    return :simulator_layer
  when "remove a simulator"
    sim_names = ["Cancel"] + slc.dumpable_simulators
    selected = Dialog::select_one( sim_names, "Select a simulator to be removed.")
    return :simulator_layer if selected == 0
    flag = slc.remove_simulator( sim_names[selected])
    if flag
      Dialog::message("Simulator \"#{sim_names[selected]}\" have been successfully removed from the database.")
    else
      Dialog::message("Failed to remove the simulator \"#{sim_names[selected]}\". There are uncompleted jobs.")
    end
    return :simulator_layer
  when "dump a simulator"
    sim_names = ["Cancel"] + slc.dumpable_simulators
    selected = Dialog::select_one( sim_names, "Select a simulator to be dumped.")
    return :simulator_layer if selected == 0
    flag = slc.dump_simulator( sim_names[selected])
    if flag
      Dialog::message("Data for the simulator \"#{sim_names[selected]}\" have been successfully dumped.")
    else
      Dialog::message("Failed to dump the simulator \"#{sim_names[selected]}\". There are uncompleted jobs.")
    end
    return :simulator_layer
  when "import a simulator"
    list = ["Cancel"] + slc.importable_simulators
    selected = Dialog::select_one( list, "Select a simulator to be dumped.")
    return :simulator_layer if selected == 0
    flag = slc.import_simulator( list[selected])
    if flag
      Dialog::message("Simulator \"#{list[selected]}\" have been successfully imported.")
    else
      Dialog::message("Failed to import the simulator \"#{sim_names[selected]}\".")
    end
    return :simulator_layer
  when "exit"
    return :exit
  else
    @simulator_class = names[selected]
    return :parameter_layer
  end
end