Changeset 301


Ignore:
Timestamp:
04/16/07 02:19:47 (14 years ago)
Author:
bastiaans
Message:

job_monarch/overview.php,
job_monarch/libtoga.php:

  • fixed: php5 loop
Location:
trunk/web/addons/job_monarch
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/web/addons/job_monarch/libtoga.php

    r300 r301  
    526526                $cpus = 0;
    527527
    528                 foreach( $this->jobs as $jobid=>$jobattrs ) {
    529 
    530                         $nodes = count( $jobattrs[nodes] );
    531                         $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
    532                         $mycpus = $nodes * $ppn;
    533 
    534                         $cpus = $cpus + $mycpus;
     528                if( isset( $this->jobs ) && count( $this->jobs ) > 0 ) {
     529
     530                        foreach( $this->jobs as $jobid=>$jobattrs ) {
     531
     532                                $nodes = count( $jobattrs[nodes] );
     533                                $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
     534                                $mycpus = $nodes * $ppn;
     535
     536                                $cpus = $cpus + $mycpus;
     537                        }
    535538                }
    536539        }
  • trunk/web/addons/job_monarch/overview.php

    r300 r301  
    376376                        "return ( \$a > \$b ) ? 1 : -1;" );
    377377
    378         foreach( $jobs as $jobid => $jobattrs ) {
    379 
    380                         $state = $jobattrs[status];
    381                         $user = $jobattrs[owner];
    382                         $queue = $jobattrs[queue];
    383                         $name = $jobattrs[name];
    384                         $req_cpu = $jobattrs[requested_time];
    385                         $req_memory = $jobattrs[requested_memory];
    386 
    387                         if( $state == 'R' )
    388                                 $nodes = count( $jobattrs[nodes] );
    389                         else
    390                                 $nodes = $jobattrs[nodes];
    391 
    392                         $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
    393                         $cpus = $nodes * $ppn;
    394                         $queued_time = (int) $jobattrs[queued_timestamp];
    395                         $start_time = (int) $jobattrs[start_timestamp];
    396                         $runningtime = $report_time - $start_time;
    397 
    398                         switch( $sortby ) {
    399                                 case "id":
    400                                         $sorted[$jobid] = $jobid;
    401                                         break;
    402 
    403                                 case "state":
    404                                         $sorted[$jobid] = $state;
    405                                         break;
    406 
    407                                 case "user":
    408                                         $sorted[$jobid] = $user;
    409                                         break;
    410 
    411                                 case "queue":
    412                                         $sorted[$jobid] = $queue;
    413                                         break;
    414 
    415                                 case "name":
    416                                         $sorted[$jobid] = $name;
    417                                         break;
    418 
    419                                 case "req_cpu":
    420                                         $sorted[$jobid] = timeToEpoch( $req_cpu );
    421                                         break;
    422 
    423                                 case "req_mem":
    424                                         $sorted[$jobid] = $req_memory;
    425                                         break;
    426 
    427                                 case "nodes":
    428                                         $sorted[$jobid] = $nodes;
    429                                         break;
    430 
    431                                 case "cpus":
    432                                         $sorted[$jobid] = $cpus;
    433                                         break;
    434 
    435                                 case "queued":
    436                                         $sorted[$jobid] = $queued_time;
    437                                         break;
    438 
    439                                 case "start":
    440                                         $sorted[$jobid] = $start_time;
    441                                         break;
    442 
    443                                 case "runningtime":
    444                                         $sorted[$jobid] = $runningtime;
    445                                         break;
    446 
    447                                 default:
    448                                         break;
    449 
    450                         }
    451         }
     378        if( isset( $jobs ) && count( $jobs ) > 0 ) {
     379
     380                foreach( $jobs as $jobid => $jobattrs ) {
     381
     382                                $state = $jobattrs[status];
     383                                $user = $jobattrs[owner];
     384                                $queue = $jobattrs[queue];
     385                                $name = $jobattrs[name];
     386                                $req_cpu = $jobattrs[requested_time];
     387                                $req_memory = $jobattrs[requested_memory];
     388
     389                                if( $state == 'R' )
     390                                        $nodes = count( $jobattrs[nodes] );
     391                                else
     392                                        $nodes = $jobattrs[nodes];
     393
     394                                $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
     395                                $cpus = $nodes * $ppn;
     396                                $queued_time = (int) $jobattrs[queued_timestamp];
     397                                $start_time = (int) $jobattrs[start_timestamp];
     398                                $runningtime = $report_time - $start_time;
     399
     400                                switch( $sortby ) {
     401                                        case "id":
     402                                                $sorted[$jobid] = $jobid;
     403                                                break;
     404
     405                                        case "state":
     406                                                $sorted[$jobid] = $state;
     407                                                break;
     408
     409                                        case "user":
     410                                                $sorted[$jobid] = $user;
     411                                                break;
     412
     413                                        case "queue":
     414                                                $sorted[$jobid] = $queue;
     415                                                break;
     416
     417                                        case "name":
     418                                                $sorted[$jobid] = $name;
     419                                                break;
     420
     421                                        case "req_cpu":
     422                                                $sorted[$jobid] = timeToEpoch( $req_cpu );
     423                                                break;
     424
     425                                        case "req_mem":
     426                                                $sorted[$jobid] = $req_memory;
     427                                                break;
     428
     429                                        case "nodes":
     430                                                $sorted[$jobid] = $nodes;
     431                                                break;
     432
     433                                        case "cpus":
     434                                                $sorted[$jobid] = $cpus;
     435                                                break;
     436
     437                                        case "queued":
     438                                                $sorted[$jobid] = $queued_time;
     439                                                break;
     440
     441                                        case "start":
     442                                                $sorted[$jobid] = $start_time;
     443                                                break;
     444
     445                                        case "runningtime":
     446                                                $sorted[$jobid] = $runningtime;
     447                                                break;
     448
     449                                        default:
     450                                                break;
     451
     452                                }
     453                }
     454        }
    452455
    453456        //uasort( $sorted, $cmp );
Note: See TracChangeset for help on using the changeset viewer.