001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018 package org.apache.hadoop.mapreduce; 019 020 import java.io.DataInput; 021 import java.io.DataOutput; 022 import java.io.IOException; 023 import java.util.HashMap; 024 import java.util.Map; 025 import java.util.Map.Entry; 026 027 import org.apache.hadoop.classification.InterfaceAudience; 028 import org.apache.hadoop.classification.InterfaceStability; 029 import org.apache.hadoop.io.Text; 030 import org.apache.hadoop.io.Writable; 031 import org.apache.hadoop.io.WritableFactories; 032 import org.apache.hadoop.io.WritableFactory; 033 import org.apache.hadoop.io.WritableUtils; 034 import org.apache.hadoop.security.authorize.AccessControlList; 035 036 /************************************************** 037 * Describes the current status of a job. 038 **************************************************/ 039 @InterfaceAudience.Public 040 @InterfaceStability.Evolving 041 public class JobStatus implements Writable, Cloneable { 042 043 static { // register a ctor 044 WritableFactories.setFactory 045 (JobStatus.class, 046 new WritableFactory() { 047 public Writable newInstance() { return new JobStatus(); } 048 }); 049 } 050 051 /** 052 * Current state of the job 053 */ 054 public static enum State { 055 RUNNING(1), 056 SUCCEEDED(2), 057 FAILED(3), 058 PREP(4), 059 KILLED(5); 060 061 int value; 062 063 State(int value) { 064 this.value = value; 065 } 066 067 public int getValue() { 068 return value; 069 } 070 071 }; 072 073 private JobID jobid; 074 private float mapProgress; 075 private float reduceProgress; 076 private float cleanupProgress; 077 private float setupProgress; 078 private State runState; 079 private long startTime; 080 private String user; 081 private String queue; 082 private JobPriority priority; 083 private String schedulingInfo="NA"; 084 private String failureInfo = "NA"; 085 086 private Map<JobACL, AccessControlList> jobACLs = 087 new HashMap<JobACL, AccessControlList>(); 088 089 private String jobName; 090 private String jobFile; 091 private long finishTime; 092 private boolean isRetired; 093 private String historyFile = ""; 094 private String trackingUrl =""; 095 private int numUsedSlots; 096 private int numReservedSlots; 097 private int usedMem; 098 private int reservedMem; 099 private int neededMem; 100 private boolean isUber; 101 102 /** 103 */ 104 public JobStatus() { 105 } 106 107 /** 108 * Create a job status object for a given jobid. 109 * @param jobid The jobid of the job 110 * @param setupProgress The progress made on the setup 111 * @param mapProgress The progress made on the maps 112 * @param reduceProgress The progress made on the reduces 113 * @param cleanupProgress The progress made on the cleanup 114 * @param runState The current state of the job 115 * @param jp Priority of the job. 116 * @param user userid of the person who submitted the job. 117 * @param jobName user-specified job name. 118 * @param jobFile job configuration file. 119 * @param trackingUrl link to the web-ui for details of the job. 120 */ 121 public JobStatus(JobID jobid, float setupProgress, float mapProgress, 122 float reduceProgress, float cleanupProgress, 123 State runState, JobPriority jp, String user, String jobName, 124 String jobFile, String trackingUrl) { 125 this(jobid, setupProgress, mapProgress, reduceProgress, cleanupProgress, 126 runState, jp, user, jobName, "default", jobFile, trackingUrl, false); 127 } 128 129 /** 130 * Create a job status object for a given jobid. 131 * @param jobid The jobid of the job 132 * @param setupProgress The progress made on the setup 133 * @param mapProgress The progress made on the maps 134 * @param reduceProgress The progress made on the reduces 135 * @param cleanupProgress The progress made on the cleanup 136 * @param runState The current state of the job 137 * @param jp Priority of the job. 138 * @param user userid of the person who submitted the job. 139 * @param jobName user-specified job name. 140 * @param queue queue name 141 * @param jobFile job configuration file. 142 * @param trackingUrl link to the web-ui for details of the job. 143 */ 144 public JobStatus(JobID jobid, float setupProgress, float mapProgress, 145 float reduceProgress, float cleanupProgress, 146 State runState, JobPriority jp, 147 String user, String jobName, String queue, 148 String jobFile, String trackingUrl) { 149 this(jobid, setupProgress, mapProgress, reduceProgress, cleanupProgress, 150 runState, jp, user, jobName, queue, jobFile, trackingUrl, false); 151 } 152 153 /** 154 * Create a job status object for a given jobid. 155 * @param jobid The jobid of the job 156 * @param setupProgress The progress made on the setup 157 * @param mapProgress The progress made on the maps 158 * @param reduceProgress The progress made on the reduces 159 * @param cleanupProgress The progress made on the cleanup 160 * @param runState The current state of the job 161 * @param jp Priority of the job. 162 * @param user userid of the person who submitted the job. 163 * @param jobName user-specified job name. 164 * @param queue queue name 165 * @param jobFile job configuration file. 166 * @param trackingUrl link to the web-ui for details of the job. 167 * @param isUber Whether job running in uber mode 168 */ 169 public JobStatus(JobID jobid, float setupProgress, float mapProgress, 170 float reduceProgress, float cleanupProgress, 171 State runState, JobPriority jp, 172 String user, String jobName, String queue, 173 String jobFile, String trackingUrl, boolean isUber) { 174 this.jobid = jobid; 175 this.setupProgress = setupProgress; 176 this.mapProgress = mapProgress; 177 this.reduceProgress = reduceProgress; 178 this.cleanupProgress = cleanupProgress; 179 this.runState = runState; 180 this.user = user; 181 this.queue = queue; 182 if (jp == null) { 183 throw new IllegalArgumentException("Job Priority cannot be null."); 184 } 185 priority = jp; 186 this.jobName = jobName; 187 this.jobFile = jobFile; 188 this.trackingUrl = trackingUrl; 189 this.isUber = isUber; 190 } 191 192 193 /** 194 * Sets the map progress of this job 195 * @param p The value of map progress to set to 196 */ 197 protected synchronized void setMapProgress(float p) { 198 this.mapProgress = (float) Math.min(1.0, Math.max(0.0, p)); 199 } 200 201 /** 202 * Sets the cleanup progress of this job 203 * @param p The value of cleanup progress to set to 204 */ 205 protected synchronized void setCleanupProgress(float p) { 206 this.cleanupProgress = (float) Math.min(1.0, Math.max(0.0, p)); 207 } 208 209 /** 210 * Sets the setup progress of this job 211 * @param p The value of setup progress to set to 212 */ 213 protected synchronized void setSetupProgress(float p) { 214 this.setupProgress = (float) Math.min(1.0, Math.max(0.0, p)); 215 } 216 217 /** 218 * Sets the reduce progress of this Job 219 * @param p The value of reduce progress to set to 220 */ 221 protected synchronized void setReduceProgress(float p) { 222 this.reduceProgress = (float) Math.min(1.0, Math.max(0.0, p)); 223 } 224 225 /** 226 * Set the priority of the job, defaulting to NORMAL. 227 * @param jp new job priority 228 */ 229 protected synchronized void setPriority(JobPriority jp) { 230 if (jp == null) { 231 throw new IllegalArgumentException("Job priority cannot be null."); 232 } 233 priority = jp; 234 } 235 236 /** 237 * Set the finish time of the job 238 * @param finishTime The finishTime of the job 239 */ 240 protected synchronized void setFinishTime(long finishTime) { 241 this.finishTime = finishTime; 242 } 243 244 /** 245 * Set the job history file url for a completed job 246 */ 247 protected synchronized void setHistoryFile(String historyFile) { 248 this.historyFile = historyFile; 249 } 250 251 /** 252 * Set the link to the web-ui for details of the job. 253 */ 254 protected synchronized void setTrackingUrl(String trackingUrl) { 255 this.trackingUrl = trackingUrl; 256 } 257 258 /** 259 * Set the job retire flag to true. 260 */ 261 protected synchronized void setRetired() { 262 this.isRetired = true; 263 } 264 265 /** 266 * Change the current run state of the job. 267 */ 268 protected synchronized void setState(State state) { 269 this.runState = state; 270 } 271 272 /** 273 * Set the start time of the job 274 * @param startTime The startTime of the job 275 */ 276 protected synchronized void setStartTime(long startTime) { 277 this.startTime = startTime; 278 } 279 280 /** 281 * @param userName The username of the job 282 */ 283 protected synchronized void setUsername(String userName) { 284 this.user = userName; 285 } 286 287 /** 288 * Used to set the scheduling information associated to a particular Job. 289 * 290 * @param schedulingInfo Scheduling information of the job 291 */ 292 protected synchronized void setSchedulingInfo(String schedulingInfo) { 293 this.schedulingInfo = schedulingInfo; 294 } 295 296 /** 297 * Set the job acls. 298 * 299 * @param acls {@link Map} from {@link JobACL} to {@link AccessControlList} 300 */ 301 protected synchronized void setJobACLs(Map<JobACL, AccessControlList> acls) { 302 this.jobACLs = acls; 303 } 304 305 /** 306 * Set queue name 307 * @param queue queue name 308 */ 309 protected synchronized void setQueue(String queue) { 310 this.queue = queue; 311 } 312 313 /** 314 * Set diagnostic information. 315 * @param failureInfo diagnostic information 316 */ 317 protected synchronized void setFailureInfo(String failureInfo) { 318 this.failureInfo = failureInfo; 319 } 320 321 /** 322 * Get queue name 323 * @return queue name 324 */ 325 public synchronized String getQueue() { 326 return queue; 327 } 328 329 /** 330 * @return Percentage of progress in maps 331 */ 332 public synchronized float getMapProgress() { return mapProgress; } 333 334 /** 335 * @return Percentage of progress in cleanup 336 */ 337 public synchronized float getCleanupProgress() { return cleanupProgress; } 338 339 /** 340 * @return Percentage of progress in setup 341 */ 342 public synchronized float getSetupProgress() { return setupProgress; } 343 344 /** 345 * @return Percentage of progress in reduce 346 */ 347 public synchronized float getReduceProgress() { return reduceProgress; } 348 349 /** 350 * @return running state of the job 351 */ 352 public synchronized State getState() { return runState; } 353 354 /** 355 * @return start time of the job 356 */ 357 synchronized public long getStartTime() { return startTime;} 358 359 @Override 360 public Object clone() { 361 try { 362 return super.clone(); 363 } catch (CloneNotSupportedException cnse) { 364 // Shouldn't happen since we do implement Clonable 365 throw new InternalError(cnse.toString()); 366 } 367 } 368 369 /** 370 * @return The jobid of the Job 371 */ 372 public JobID getJobID() { return jobid; } 373 374 /** 375 * @return the username of the job 376 */ 377 public synchronized String getUsername() { return this.user;} 378 379 /** 380 * Gets the Scheduling information associated to a particular Job. 381 * @return the scheduling information of the job 382 */ 383 public synchronized String getSchedulingInfo() { 384 return schedulingInfo; 385 } 386 387 /** 388 * Get the job acls. 389 * 390 * @return a {@link Map} from {@link JobACL} to {@link AccessControlList} 391 */ 392 public synchronized Map<JobACL, AccessControlList> getJobACLs() { 393 return jobACLs; 394 } 395 396 /** 397 * Return the priority of the job 398 * @return job priority 399 */ 400 public synchronized JobPriority getPriority() { return priority; } 401 402 /** 403 * Gets any available info on the reason of failure of the job. 404 * @return diagnostic information on why a job might have failed. 405 */ 406 public synchronized String getFailureInfo() { 407 return this.failureInfo; 408 } 409 410 411 /** 412 * Returns true if the status is for a completed job. 413 */ 414 public synchronized boolean isJobComplete() { 415 return (runState == JobStatus.State.SUCCEEDED || 416 runState == JobStatus.State.FAILED || 417 runState == JobStatus.State.KILLED); 418 } 419 420 /////////////////////////////////////// 421 // Writable 422 /////////////////////////////////////// 423 public synchronized void write(DataOutput out) throws IOException { 424 jobid.write(out); 425 out.writeFloat(setupProgress); 426 out.writeFloat(mapProgress); 427 out.writeFloat(reduceProgress); 428 out.writeFloat(cleanupProgress); 429 WritableUtils.writeEnum(out, runState); 430 out.writeLong(startTime); 431 Text.writeString(out, user); 432 WritableUtils.writeEnum(out, priority); 433 Text.writeString(out, schedulingInfo); 434 out.writeLong(finishTime); 435 out.writeBoolean(isRetired); 436 Text.writeString(out, historyFile); 437 Text.writeString(out, jobName); 438 Text.writeString(out, trackingUrl); 439 Text.writeString(out, jobFile); 440 out.writeBoolean(isUber); 441 442 // Serialize the job's ACLs 443 out.writeInt(jobACLs.size()); 444 for (Entry<JobACL, AccessControlList> entry : jobACLs.entrySet()) { 445 WritableUtils.writeEnum(out, entry.getKey()); 446 entry.getValue().write(out); 447 } 448 } 449 450 public synchronized void readFields(DataInput in) throws IOException { 451 this.jobid = new JobID(); 452 this.jobid.readFields(in); 453 this.setupProgress = in.readFloat(); 454 this.mapProgress = in.readFloat(); 455 this.reduceProgress = in.readFloat(); 456 this.cleanupProgress = in.readFloat(); 457 this.runState = WritableUtils.readEnum(in, State.class); 458 this.startTime = in.readLong(); 459 this.user = Text.readString(in); 460 this.priority = WritableUtils.readEnum(in, JobPriority.class); 461 this.schedulingInfo = Text.readString(in); 462 this.finishTime = in.readLong(); 463 this.isRetired = in.readBoolean(); 464 this.historyFile = Text.readString(in); 465 this.jobName = Text.readString(in); 466 this.trackingUrl = Text.readString(in); 467 this.jobFile = Text.readString(in); 468 this.isUber = in.readBoolean(); 469 470 // De-serialize the job's ACLs 471 int numACLs = in.readInt(); 472 for (int i = 0; i < numACLs; i++) { 473 JobACL aclType = WritableUtils.readEnum(in, JobACL.class); 474 AccessControlList acl = new AccessControlList(" "); 475 acl.readFields(in); 476 this.jobACLs.put(aclType, acl); 477 } 478 } 479 480 /** 481 * Get the user-specified job name. 482 */ 483 public String getJobName() { 484 return jobName; 485 } 486 487 /** 488 * Get the configuration file for the job. 489 */ 490 public String getJobFile() { 491 return jobFile; 492 } 493 494 /** 495 * Get the link to the web-ui for details of the job. 496 */ 497 public synchronized String getTrackingUrl() { 498 return trackingUrl; 499 } 500 501 /** 502 * Get the finish time of the job. 503 */ 504 public synchronized long getFinishTime() { 505 return finishTime; 506 } 507 508 /** 509 * Check whether the job has retired. 510 */ 511 public synchronized boolean isRetired() { 512 return isRetired; 513 } 514 515 /** 516 * @return the job history file name for a completed job. If job is not 517 * completed or history file not available then return null. 518 */ 519 public synchronized String getHistoryFile() { 520 return historyFile; 521 } 522 523 /** 524 * @return number of used mapred slots 525 */ 526 public int getNumUsedSlots() { 527 return numUsedSlots; 528 } 529 530 /** 531 * @param n number of used mapred slots 532 */ 533 public void setNumUsedSlots(int n) { 534 numUsedSlots = n; 535 } 536 537 /** 538 * @return the number of reserved slots 539 */ 540 public int getNumReservedSlots() { 541 return numReservedSlots; 542 } 543 544 /** 545 * @param n the number of reserved slots 546 */ 547 public void setNumReservedSlots(int n) { 548 this.numReservedSlots = n; 549 } 550 551 /** 552 * @return the used memory 553 */ 554 public int getUsedMem() { 555 return usedMem; 556 } 557 558 /** 559 * @param m the used memory 560 */ 561 public void setUsedMem(int m) { 562 this.usedMem = m; 563 } 564 565 /** 566 * @return the reserved memory 567 */ 568 public int getReservedMem() { 569 return reservedMem; 570 } 571 572 /** 573 * @param r the reserved memory 574 */ 575 public void setReservedMem(int r) { 576 this.reservedMem = r; 577 } 578 579 /** 580 * @return the needed memory 581 */ 582 public int getNeededMem() { 583 return neededMem; 584 } 585 586 /** 587 * @param n the needed memory 588 */ 589 public void setNeededMem(int n) { 590 this.neededMem = n; 591 } 592 593 /** 594 * Whether job running in uber mode 595 * @return job in uber-mode 596 */ 597 public synchronized boolean isUber() { 598 return isUber; 599 } 600 601 /** 602 * Set uber-mode flag 603 * @param isUber Whether job running in uber-mode 604 */ 605 public synchronized void setUber(boolean isUber) { 606 this.isUber = isUber; 607 } 608 609 public String toString() { 610 StringBuffer buffer = new StringBuffer(); 611 buffer.append("job-id : " + jobid); 612 buffer.append("uber-mode : " + isUber); 613 buffer.append("map-progress : " + mapProgress); 614 buffer.append("reduce-progress : " + reduceProgress); 615 buffer.append("cleanup-progress : " + cleanupProgress); 616 buffer.append("setup-progress : " + setupProgress); 617 buffer.append("runstate : " + runState); 618 buffer.append("start-time : " + startTime); 619 buffer.append("user-name : " + user); 620 buffer.append("priority : " + priority); 621 buffer.append("scheduling-info : " + schedulingInfo); 622 buffer.append("num-used-slots" + numUsedSlots); 623 buffer.append("num-reserved-slots" + numReservedSlots); 624 buffer.append("used-mem" + usedMem); 625 buffer.append("reserved-mem" + reservedMem); 626 buffer.append("needed-mem" + neededMem); 627 return buffer.toString(); 628 } 629 }