would love to have tests, but then you have to somehow setup a clean slurm environemnt and start dummy jobs there. not sure how to best do that.

this is the part you need to debug:

turm/src/job_watcher.rs

Lines 53 to 133 in f104c7c

    
           let jobs: Vec<Job> = Command::new("squeue") 
        
               .args(&self.squeue_args) 
        
               .arg("--array") 
        
               .arg("--noheader") 
        
               .arg("--Format") 
        
               .arg(&output_format) 
        
               .output() 
        
               .expect("failed to execute process") 
        
               .stdout 
        
               .lines() 
        
               .map(|l| l.unwrap().trim().to_string()) 
        
               .filter_map(|l| { 
        
                   let parts: Vec<_> = l.split(output_separator).collect(); 
        
                   if parts.len() != fields.len() + 1 { 
        
                       return None; 
        
                   } 
        
                   let id = parts[0]; 
        
                   let name = parts[1]; 
        
                   let state = parts[2]; 
        
                   let user = parts[3]; 
        
                   let time = parts[4]; 
        
                   let tres = parts[5]; 
        
                   let partition = parts[6]; 
        
                   let nodelist = parts[7]; 
        
                   let stdout = parts[8]; 
        
                   let stderr = parts[9]; 
        
                   let command = parts[10]; 
        
                   let state_compact = parts[11]; 
        
                   let reason = parts[12]; 
        
                   let array_job_id = parts[13]; 
        
                   let array_task_id = parts[14]; 
        
                   let node_list = parts[15]; 
        
                   let working_dir = parts[16]; 
        
                   Some(Job { 
        
                       job_id: id.to_owned(), 
        
                       array_id: array_job_id.to_owned(), 
        
                       array_step: match array_task_id { 
        
                           "N/A" => None, 
        
                           _ => Some(array_task_id.to_owned()), 
        
                       }, 
        
                       name: name.to_owned(), 
        
                       state: state.to_owned(), 
        
                       state_compact: state_compact.to_owned(), 
        
                       reason: if reason == "None" { 
        
                           None 
        
                       } else { 
        
                           Some(reason.to_owned()) 
        
                       }, 
        
                       user: user.to_owned(), 
        
                       time: time.to_owned(), 
        
                       tres: tres.to_owned(), 
        
                       partition: partition.to_owned(), 
        
                       nodelist: nodelist.to_owned(), 
        
                       command: command.to_owned(), 
        
                       stdout: Self::resolve_path( 
        
                           stdout, 
        
                           array_job_id, 
        
                           array_task_id, 
        
                           id, 
        
                           node_list, 
        
                           user, 
        
                           name, 
        
                           working_dir, 
        
                       ), 
        
                       stderr: Self::resolve_path( 
        
                           stderr, 
        
                           array_job_id, 
        
                           array_task_id, 
        
                           id, 
        
                           node_list, 
        
                           user, 
        
                           name, 
        
                           working_dir, 
        
                       ), // TODO fill all fields 
        
                   }) 
        
               }) 
        
               .collect();

	let jobs: Vec<Job> = Command::new("squeue")
	.args(&self.squeue_args)
	.arg("--array")
	.arg("--noheader")
	.arg("--Format")
	.arg(&output_format)
	.output()
	.expect("failed to execute process")
	.stdout
	.lines()
	.map(\|l\| l.unwrap().trim().to_string())
	.filter_map(\|l\| {
	let parts: Vec<_> = l.split(output_separator).collect();

	if parts.len() != fields.len() + 1 {
	return None;
	}

	let id = parts[0];
	let name = parts[1];
	let state = parts[2];
	let user = parts[3];
	let time = parts[4];
	let tres = parts[5];
	let partition = parts[6];
	let nodelist = parts[7];
	let stdout = parts[8];
	let stderr = parts[9];
	let command = parts[10];
	let state_compact = parts[11];
	let reason = parts[12];

	let array_job_id = parts[13];
	let array_task_id = parts[14];
	let node_list = parts[15];
	let working_dir = parts[16];

	Some(Job {
	job_id: id.to_owned(),
	array_id: array_job_id.to_owned(),
	array_step: match array_task_id {
	"N/A" => None,
	_ => Some(array_task_id.to_owned()),
	},
	name: name.to_owned(),
	state: state.to_owned(),
	state_compact: state_compact.to_owned(),
	reason: if reason == "None" {
	None
	} else {
	Some(reason.to_owned())
	},
	user: user.to_owned(),
	time: time.to_owned(),
	tres: tres.to_owned(),
	partition: partition.to_owned(),
	nodelist: nodelist.to_owned(),
	command: command.to_owned(),
	stdout: Self::resolve_path(
	stdout,
	array_job_id,
	array_task_id,
	id,
	node_list,
	user,
	name,
	working_dir,
	),
	stderr: Self::resolve_path(
	stderr,
	array_job_id,
	array_task_id,
	id,
	node_list,
	user,
	name,
	working_dir,
	), // TODO fill all fields
	})
	})
	.collect();

Job list is empty on Slurm 18.08 #17

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions