Example #1
0
  /**
   * Mark's this <code>GridProcess</code> as running, in other words this replica will change state
   * to <code>GridProcessState.RUNNING</code> if it is in <code>GridProcessState.UNSTARTED</code>.
   *
   * @param chosenWorker Spec of the worker that will run this replica.
   */
  public void allocate(WorkerEntry chosenWorker) {

    if (!GridProcessState.UNSTARTED.equals(this.state)) {
      throw new IllegalResultException(
          "This replica is already running or has already finished execution", replicaHandle);
    }

    this.workerEntry = chosenWorker;
    RequestSpecification requestSpec = workerEntry.getRequestSpecification();

    if (requestSpec != null) {
      this.replicaAccounting =
          new GridProcessAccounting(
              requestSpec.getRequestId(),
              requestSpec.getJobId(),
              requestSpec.getRequiredWorkers(),
              requestSpec.getMaxFails(),
              requestSpec.getMaxReplicas(),
              getWorkerEntry().getWorkerID(),
              getWorkerEntry().getWorkerPublicKey(),
              workerEntry.getWorkerSpecification());
    }
  }
  public JobWorkerStatus getCompleteStatus() {

    Map<Integer, Job> jobsMap = JobInfo.getInstance().getJobs();
    Map<Integer, Set<WorkerEntry>> workersByJob = CommonUtils.createMap();

    JobStatusInfo jobInfo = null;
    List<TaskStatusInfo> tasksList = null;
    Map<Integer, JobStatusInfo> jobs = CommonUtils.createSerializableMap();

    // Jobs
    for (Job job : jobsMap.values()) {
      Set<WorkerEntry> workers = new LinkedHashSet<WorkerEntry>();
      tasksList = new ArrayList<TaskStatusInfo>();

      for (Task task : job.getTasks()) {
        tasksList.add(fillTask(task));
        for (GridProcess gridProcess : task.getGridProcesses()) {
          if (gridProcess.getState() == GridProcessState.RUNNING)
            workers.add(gridProcess.getWorkerEntry());
        }
      }

      jobInfo =
          new JobStatusInfo(
              job.getJobId(),
              job.getSpec(),
              UtilConverter.getJobState(job.getState()),
              tasksList,
              job.getCreationTime(),
              job.getFinalizationTime());

      jobs.put(jobInfo.getJobId(), jobInfo);

      if (job.isRunning()) {
        workersByJob.put(job.getJobId(), workers);
      }
    }

    Map<Integer, WorkerStatusInfo[]> workers = CommonUtils.createSerializableMap();

    WorkerStatusInfo[] workerList = null;
    for (Entry<Integer, Set<WorkerEntry>> entry : workersByJob.entrySet()) {

      workerList = workers.get(entry.getKey());
      if (workerList == null) {
        workerList = new WorkerStatusInfo[entry.getValue().size()];
        workers.put(entry.getKey(), workerList);
      }

      int i = 0;
      for (WorkerEntry workerEntry : entry.getValue()) {

        GridProcessHandle handle = null;
        String state = null;

        if (workerEntry.getGridProcess() != null) {
          handle = workerEntry.getGridProcess().getHandle();
          state = workerEntry.getGridProcess().getState().toString();
        }

        workerList[i] =
            new WorkerStatusInfo(
                workerEntry.getWorkerSpecification(), handle, workerEntry.getWorkerID(), state);
        i++;
      }
    }

    JobWorkerStatus status = new JobWorkerStatus(jobs, workers);

    return status;
  }
 public int compare(WorkerEntry o1, WorkerEntry o2) {
   return workerSpecAnnotationsComparator.compare(
       o1.getWorkerSpecification(), o2.getWorkerSpecification());
 }