Examples of org.apache.uima.ducc.transport.event.common.DuccWorkJob

Package org.apache.uima.ducc.transport.event.common

Examples of org.apache.uima.ducc.transport.event.common.DuccWorkJob

org.apache.uima.ducc.transport.event.common.DuccWorkJob

      DuccId duccId = workMapIterator.next();
      IDuccWork duccWork = workMap.findDuccWork(duccId);
      switch(duccWork.getDuccType()) {
      case Job:
      case Service:
        DuccWorkJob duccWorkJob = (DuccWorkJob)duccWork;
        if(duccWorkJob != null) {
          if(duccWorkJob.isCompleting() && allProcessesTerminated(duccWorkJob)) {
            stateJobAccounting.stateChange(duccWorkJob, JobState.Completed);
          }
          if(duccWorkJob.isCompleted() && allProcessesTerminated(duccWorkJob) && isSaved(duccWorkJob) && isAgedOut(duccWorkJob)) {
            workMap.removeDuccWork(duccId);
            driverStatusReportMap.remove(duccId);
            logger.info(methodName, duccId, messages.fetch("removed job"));
            changes ++;
            IDuccProcessMap processMap = duccWorkJob.getProcessMap();
            Iterator<DuccId> processMapIterator = processMap.keySet().iterator();
            while(processMapIterator.hasNext()) {
              DuccId processDuccId = processMapIterator.next();
              orchestratorCommonArea.getProcessAccounting().removeProcess(processDuccId);
              logger.info(methodName, duccId, messages.fetch("removed process")+" "+processDuccId.toString());

View Full Code Here

    logger.trace(methodName, null, messages.fetch("enter"));
    int changes = 0;
    long t0 = System.currentTimeMillis();
    synchronized(workMap) {
      DuccId duccId = jdStatusReport.getDuccId();
      DuccWorkJob duccWorkJob = (DuccWorkJob) workMap.findDuccWork(duccId);
      if(duccWorkJob != null) {
        String jdJmxUrl = jdStatusReport.getJdJmxUrl();
        setJdJmxUrl(duccWorkJob, jdJmxUrl);
        IDuccUimaDeploymentDescriptor uimaDeploymentDescriptor = jdStatusReport.getUimaDeploymentDescriptor();
        if(uimaDeploymentDescriptor != null) {
          boolean copyDD = true;
          if(copyDD) {
            duccWorkJob.setUimaDeployableConfiguration(uimaDeploymentDescriptor);
          }
        }
        //
        copyProcessWorkItemsReport(duccWorkJob, jdStatusReport);
        copyDriverWorkItemsReport(duccWorkJob, jdStatusReport);
        //
        switch(duccWorkJob.getJobState()) {
        case Completed:
          break;
        case Completing:
        default:
          driverStatusReportMap.put(duccId, jdStatusReport);
          break;
        }
        //
        if(jdStatusReport.getWorkItemsTotal() == 0) {
          jobTerminate(duccWorkJob, JobCompletionType.CanceledByDriver, new Rationale("no work items to process"), ProcessDeallocationType.JobCanceled);
        }
        else {
          switch(jdStatusReport.getDriverState()) {
          case NotRunning:
            break;
          case Initializing:  
            switch(duccWorkJob.getJobState()) {
            case WaitingForDriver: 
              JobState nextState = JobState.WaitingForServices;
              if(duccWorkJob.getServiceDependencies() == null) {
                String message = messages.fetch("bypass")+" "+nextState;
                logger.debug(methodName, duccId, message);
                nextState = JobState.WaitingForResources;
              }
              stateJobAccounting.stateChange(duccWorkJob, nextState);
              break;
            case Initializing:
              break;
            }
            break;
          case Running:
          case Idle:  
            if(jdStatusReport.isKillJob()) {
              IRationale rationale = jdStatusReport.getJobCompletionRationale();
              switch(duccWorkJob.getJobState()) {
              case WaitingForServices:
                if(rationale == null) {
                  rationale = new Rationale("waiting for services");
                }
                else {
                  if(rationale.isSpecified()) {
                    String text = rationale.getText();
                    rationale = new Rationale(text+": "+"waiting for services");
                  }
                  else {
                    rationale = new Rationale("waiting for services");
                  }
                }
                break;
              default:
                break;
              }
              jobTerminate(duccWorkJob, JobCompletionType.CanceledByDriver, rationale, ProcessDeallocationType.JobFailure);
              break;
            }
            switch(duccWorkJob.getJobState()) {
            case WaitingForDriver:
              stateJobAccounting.stateChange(duccWorkJob, JobState.WaitingForServices);
              break;
            case Initializing:
              stateJobAccounting.stateChange(duccWorkJob, JobState.Running);
              break;
            }
            break;
          case Completing:  
            if(!duccWorkJob.isFinished()) {
              stateJobAccounting.stateChange(duccWorkJob, JobState.Completing);
            }
            break;
          case Completed:
            if(!duccWorkJob.isCompleted()) {
              if(!duccWorkJob.isFinished()) {
                stateJobAccounting.stateChange(duccWorkJob, JobState.Completing);
              }
              deallocateJobDriver(duccWorkJob, jdStatusReport);
              duccWorkJob.getStandardInfo().setDateOfCompletion(TimeStamp.getCurrentMillis());
              switch(jdStatusReport.getJobCompletionType()) {
              case EndOfJob:
                try {
                  int errors = Integer.parseInt(duccWorkJob.getSchedulingInfo().getWorkItemsError());
                  int lost = Integer.parseInt(duccWorkJob.getSchedulingInfo().getWorkItemsLost());
                  if(errors > 0) {
                    setCompletionIfNotAlreadySet(duccWorkJob, JobCompletionType.Error, new Rationale("state manager detected errors="+errors));
                  }
                  else if(lost > 0) {
                    setCompletionIfNotAlreadySet(duccWorkJob, JobCompletionType.Lost, new Rationale("state manager detected lost work items="+lost));

View Full Code Here

        else {
          logger.debug(methodName, duccId, messages.fetchLabel("type")+duccWork.getDuccType());
          switch(duccWork.getDuccType()) {
          case Job:
            logger.debug(methodName, duccId, messages.fetch("processing job..."));
            DuccWorkJob duccWorkJob = (DuccWorkJob) duccWork;
            processPurger(duccWorkJob,rmResourceState.getResources());
            changes += processMapResourcesAdd(duccWorkJob,rmResourceState.getPendingAdditions());
            changes += processMapResourcesDel(duccWorkJob,rmResourceState.getPendingRemovals());
            JobState jobState = duccWorkJob.getJobState();
            logger.debug(methodName, duccId, messages.fetchLabel("job state")+jobState);
            switch(jobState) {
            case Received:
            case WaitingForDriver:
              logger.warn(methodName, duccId, messages.fetchLabel("unexpected state")+jobState);
              break;
            case WaitingForServices:
              logger.debug(methodName, duccId, messages.fetchLabel("unexpected state")+jobState);
              break;
            case WaitingForResources:
              if(rmResourceState.isRefused()) {
                duccWorkJob.getStandardInfo().setDateOfCompletion(TimeStamp.getCurrentMillis());
                duccWorkJob.setCompletionType(JobCompletionType.ResourcesUnavailable);
                duccWorkJob.setCompletionRationale(new Rationale("resource manager refused allocation: "+rmResourceState.getReason()));
                changes += stateChange(duccWorkJob,JobState.Completed);
                logger.warn(methodName, duccId, messages.fetchLabel("refused")+rmResourceState.getReason());
                String userName = duccWorkJob.getStandardInfo().getUser();
                String userLogDir = duccWorkJob.getUserLogsDir()+duccWorkJob.getDuccId().getFriendly()+File.separator;;
                String text = rmResourceState.getReason();
                UserLogging.record(userName, userLogDir, text);
              }
              if(duccWorkJob.getProcessMap().size() > 0) {
                changes += stateChange(duccWorkJob,JobState.Initializing);
                logger.info(methodName, duccId, messages.fetchLabel("resources count")+duccWorkJob.getProcessMap().size());
              }
              break;
            case Initializing:
            case Running:
              if(duccWorkJob.getProcessMap().size() == 0) {
                changes += stateChange(duccWorkJob,JobState.WaitingForResources);
                logger.info(methodName, duccId, messages.fetchLabel("resources count")+duccWorkJob.getProcessMap().size());
              }
              break;
            case Completing:
            case Completed:
              logger.debug(methodName, duccId, messages.fetchLabel("unsuitable state")+jobState);
              break;
            case Undefined:
              logger.warn(methodName, duccId, messages.fetchLabel("unsuitable state")+jobState);
              break;
            }
            break;
          case Reservation:
            logger.debug(methodName, duccId, messages.fetch("processing reservation..."));
            DuccWorkReservation duccWorkReservation = (DuccWorkReservation) duccWork;
            changes += reservationMapResourcesAdd(duccWorkReservation,rmResourceState.getPendingAdditions());
            changes += reservationMapResourcesDel(duccWorkReservation,rmResourceState.getPendingRemovals());
            ReservationState reservationState = duccWorkReservation.getReservationState();
            switch(reservationState) {
            case Received:
              logger.warn(methodName, duccId, messages.fetchLabel("unexpected state")+reservationState);
              break;
            case WaitingForResources:
              if(rmResourceState.isRefused()) {
                String schedulingClass = duccWorkReservation.getSchedulingInfo().getSchedulingClass().trim();
                if(schedulingClass.equals(DuccSchedulerClasses.JobDriver)) {
                  if(!refusedLogged.get()) {
                    logger.warn(methodName, duccId, messages.fetchLabel("refusal ignored")+rmResourceState.getReason());
                    refusedLogged.set(true);
                  }
                }
                else {
                  duccWorkReservation.getStandardInfo().setDateOfCompletion(TimeStamp.getCurrentMillis());
                  duccWorkReservation.setCompletionType(ReservationCompletionType.ResourcesUnavailable);
                  duccWorkReservation.setCompletionRationale(new Rationale("resource manager refused allocation: "+rmResourceState.getReason()));
                  changes += stateChange(duccWorkReservation,ReservationState.Completed);
                  logger.warn(methodName, duccId, messages.fetchLabel("refused")+rmResourceState.getReason());
                }
              }
              else {
                if(rmResourceState.getResources() != null) {
                  if(!rmResourceState.getResources().isEmpty()) {
                    changes += stateChange(duccWorkReservation,ReservationState.Assigned);
                    logger.info(methodName, duccId, messages.fetchLabel("resources count")+rmResourceState.getResources().size());
                  }
                }
                else {
                  logger.info(methodName, duccId, messages.fetch("waiting...no resources?"));
                }
              }
              break;
            case Assigned:
              if(rmResourceState.getResources() != null) {
                if(rmResourceState.getResources().isEmpty()) {
                  changes += stateChange(duccWorkReservation,ReservationState.Completed);
                  logger.info(methodName, duccId, messages.fetchLabel("resources count")+rmResourceState.getResources().size());
                }
              }
              else {
                logger.info(methodName, duccId, messages.fetch("assigned...no resources?"));
              }
              break;
            case Completed:
              logger.debug(methodName, duccId, messages.fetchLabel("unsuitable state")+reservationState);
              break;
            case Undefined:
              logger.warn(methodName, duccId, messages.fetchLabel("unsuitable state")+reservationState);
              break;
            }
            break;
          case Service:
            logger.debug(methodName, duccId, messages.fetch("processing service..."));
            DuccWorkJob duccWorkService = (DuccWorkJob) duccWork;
            processPurger(duccWorkService,rmResourceState.getResources());
            changes += processMapResourcesAdd(duccWorkService,rmResourceState.getPendingAdditions());
            changes += processMapResourcesDel(duccWorkService,rmResourceState.getPendingRemovals());
            JobState serviceState = duccWorkService.getJobState();
            logger.debug(methodName, duccId, messages.fetchLabel("service state")+serviceState);
            switch(serviceState) {
            case Received:
              logger.warn(methodName, duccId, messages.fetchLabel("unexpected state")+serviceState);
              break;
            case WaitingForServices:
              logger.debug(methodName, duccId, messages.fetchLabel("unexpected state")+serviceState);
              break;
            case WaitingForResources:
              if(rmResourceState.isRefused()) {
                duccWorkService.getStandardInfo().setDateOfCompletion(TimeStamp.getCurrentMillis());
                duccWorkService.setCompletionType(JobCompletionType.ResourcesUnavailable);
                duccWorkService.setCompletionRationale(new Rationale("resource manager refused allocation: "+rmResourceState.getReason()));
                changes += stateChange(duccWorkService,JobState.Completed);
                logger.warn(methodName, duccId, messages.fetchLabel("refused")+rmResourceState.getReason());
                String userName = duccWorkService.getStandardInfo().getUser();
                String userLogDir = duccWorkService.getUserLogsDir()+duccWorkService.getDuccId().getFriendly()+File.separator;;
                String text = rmResourceState.getReason();
                UserLogging.record(userName, userLogDir, text);
              }
              if(duccWorkService.getProcessMap().size() > 0) {
                changes += stateChange(duccWorkService,JobState.Initializing);
                logger.info(methodName, duccId, messages.fetchLabel("resources count")+duccWorkService.getProcessMap().size());
              }
              break;
            case Initializing:
            case Running:
              if(duccWorkService.getProcessMap().size() == 0) {
                changes += stateChange(duccWorkService,JobState.WaitingForResources);
                logger.info(methodName, duccId, messages.fetchLabel("resources count")+duccWorkService.getProcessMap().size());
              }
              break;
            case Completing:
            case Completed:
              logger.debug(methodName, duccId, messages.fetchLabel("unsuitable state")+serviceState);

View Full Code Here

    long t0 = System.currentTimeMillis();
    synchronized(workMap) {
      while(serviceMapIterator.hasNext()) {
        DuccId duccId = serviceMapIterator.next();
        ServiceDependency services = serviceMap.get(duccId);
        DuccWorkJob duccWorkJob = (DuccWorkJob) workMap.findDuccWork(duccId);
        if(duccWorkJob != null) {
          JobState jobState = duccWorkJob.getJobState();
          ServiceState serviceState = services.getState();
          switch(jobState) {
          case Received:
            logger.warn(methodName, duccId, messages.fetchLabel("unexpected job state")+jobState);
            break;
          case WaitingForDriver:
            logger.debug(methodName, duccId, messages.fetchLabel("pending job state")+jobState);
            break;
          case WaitingForServices:
            switch(serviceState) {
            case Waiting:
                        case Starting:
            case Initializing:
              break;
            case Available:
              stateJobAccounting.stateChange(duccWorkJob, JobState.WaitingForResources);
              changes++;
              logger.info(methodName, duccId, messages.fetchLabel("job state")+jobState+" "+messages.fetchLabel("services state")+serviceState);
              break;
            case NotAvailable:
            case Stopped:
                        case Stopping:
              stateJobAccounting.stateChange(duccWorkJob, JobState.Completing);
              duccWorkJob.getStandardInfo().setDateOfCompletion(TimeStamp.getCurrentMillis());
              String sdm = getServiceDependencyMessages(services);  
              IRationale rationale = new Rationale();
              if(sdm != null) {
                rationale = new Rationale("service manager reported "+sdm);
              }

View Full Code Here

              switch(jobType) {
              case Job:
                switch(processType) {
                case Pop:
                  OrchestratorCommonArea.getInstance().getProcessAccounting().setStatus(inventoryProcess);
                  DuccWorkJob job = (DuccWorkJob) duccWork;
                  switch(inventoryProcess.getProcessState()) {
                  case Failed:
                    if(inventoryProcess.getDuccId().getFriendly() == 0) {
                      jobTerminate(job, JobCompletionType.DriverProcessFailed, new Rationale(inventoryProcess.getReasonForStoppingProcess()), inventoryProcess.getProcessDeallocationType());
                    }
                    else {
                      jobTerminate(job, JobCompletionType.ProcessFailure, new Rationale(inventoryProcess.getReasonForStoppingProcess()), inventoryProcess.getProcessDeallocationType());
                    }
                    break;
                  default:
                    if(inventoryProcess.isComplete()) {
                      OrchestratorCommonArea.getInstance().getProcessAccounting().deallocate(job,ProcessDeallocationType.Stopped);
                      IRationale rationale = new Rationale("state manager reported as normal completion");
                      int errors = job.getSchedulingInfo().getIntWorkItemsError();
                      int lost = job.getSchedulingInfo().getIntWorkItemsLost();
                      if(errors > 0) {
                        setCompletionIfNotAlreadySet(job, JobCompletionType.Error, new Rationale("state manager detected error work items="+errors));
                      }
                      else if(lost > 0) {
                        setCompletionIfNotAlreadySet(job, JobCompletionType.Lost, new Rationale("state manager detected lost work items="+lost));
                      }
                      // <UIMA-3337>
                      else {
                        setCompletionIfNotAlreadySet(job, JobCompletionType.EndOfJob, rationale);
                      }
                      // </UIMA-3337>
                      completeJob(job, rationale);
                    }
                    break;
                  }
                  break;
                case Service:
                  logger.warn(methodName, jobId, processId, "unexpected process type: "+processType);
                  break;
                case Job_Uima_AS_Process:
                  OrchestratorCommonArea.getInstance().getProcessAccounting().setStatus(inventoryProcess);
                  break;
                }
                break;
              case Service:
                DuccWorkJob service = (DuccWorkJob) duccWork;
                switch(processType) {
                case Pop:
                  OrchestratorCommonArea.getInstance().getProcessAccounting().setStatus(inventoryProcess);
                  if(inventoryProcess.isComplete()) {
                    OrchestratorCommonArea.getInstance().getProcessAccounting().deallocate(service,ProcessDeallocationType.Stopped);
                  }
                  if(!service.hasAliveProcess()) {
                    completeManagedReservation(service, new Rationale("state manager reported no viable service process exists, type="+processType));
                  }
                  break;
                case Service:
                  OrchestratorCommonArea.getInstance().getProcessAccounting().setStatus(inventoryProcess);
                  if(inventoryProcess.isComplete()) {
                    OrchestratorCommonArea.getInstance().getProcessAccounting().deallocate(service,ProcessDeallocationType.Stopped);
                  }
                  if(!service.hasAliveProcess()) {
                    completeService(service, new Rationale("state manager reported no viable service process exists, type="+processType));
                  }
                  break;
                case Job_Uima_AS_Process:
                  OrchestratorCommonArea.getInstance().getProcessAccounting().setStatus(inventoryProcess);
                  if(inventoryProcess.isComplete()) {
                    OrchestratorCommonArea.getInstance().getProcessAccounting().deallocate(service,ProcessDeallocationType.Stopped);
                  }
                  if(!service.hasAliveProcess()) {
                    completeService(service, new Rationale("state manager reported no viable service process exists, type="+processType));
                  }
                  break;
                }
                break;

View Full Code Here


      //  Populate job list with job data that agents need. Don't copy data the agent doesnt
      //  care about.
      for( Entry<DuccId, IDuccWork> entry : workMap.entrySet() ) {
        if ( entry.getValue() instanceof DuccWorkJob ) {
          DuccWorkJob dcj = (DuccWorkJob)entry.getValue();
          //  Create process list for each job
          List<IDuccProcess> jobProcessList = new ArrayList<IDuccProcess>();
          
          long normalizedProcessMemoryRequirements = normalizeMemory(dcj.getSchedulingInfo().getShareMemorySize(),dcj.getSchedulingInfo().getShareMemoryUnits());
          int shares = getShares(normalizedProcessMemoryRequirements);
          long processAdjustedMemorySize = shares * shareQuantum * 1024;  
          ProcessMemoryAssignment pma = new ProcessMemoryAssignment();
          pma.setShares(shares);
          pma.setNormalizedMemoryInMBs(processAdjustedMemorySize);
          
      
          //  Copy job processes 
          for( Entry<DuccId,IDuccProcess> jpProcess : dcj.getProcessMap().getMap().entrySet()) {
            jobProcessList.add(jpProcess.getValue());
          }
          
          
          
          if ( dcj.getUimaDeployableConfiguration() instanceof DuccUimaDeploymentDescriptor ) {
            //  Add deployment UIMA AS deployment descriptor path
            ((JavaCommandLine)dcj.getCommandLine()).
              addArgument(((DuccUimaDeploymentDescriptor)dcj.getUimaDeployableConfiguration()).getDeploymentDescriptorPath());
          }
          
          
          //  Calculate Process memory allocation including a fudge factor (if one is defined). The
          //  returned value is in terms of Megs.
//          long processAdjustedMemorySize = 
//                  calculateProcessMemoryAssignment(dcj.getSchedulingInfo().getShareMemorySize(), 
//                          dcj.getSchedulingInfo().getShareMemoryUnits());
          //  add fudge factor (5% default)  to adjust memory computed above 
          processAdjustedMemorySize += (processAdjustedMemorySize * ((double)fudgeFactor/100));
          pma.setMaxMemoryWithFudge(processAdjustedMemorySize);
          
          logger.info(methodName,dcj.getDuccId(),"--------------- User Requested Memory For Process:"+dcj.getSchedulingInfo().getShareMemorySize()+dcj.getSchedulingInfo().getShareMemoryUnits()+" PM Calculated Memory Assignment of:"+processAdjustedMemorySize);
          
          ICommandLine driverCmdLine = null;
          IDuccProcess driverProcess = null;
          switch(dcj.getDuccType()) {
          case Job:
           
            driverCmdLine = dcj.getDriver().getCommandLine();
            driverProcess = dcj.getDriver().getProcessMap().entrySet().iterator().next().getValue();
            
            break;
          case Service:
            //logger.info(methodName,null,"!!!!!!!!!!!!! GOT SERVICE");
            break;
          
          default:
            
          }
          
          jobDeploymentList.add( new DuccJobDeployment(dcj.getDuccId(), driverCmdLine,
                             dcj.getCommandLine(), 
                             dcj.getStandardInfo(),
                             driverProcess,
                             pma,
                             //processAdjustedMemorySize,
                             jobProcessList ));
        } else if (entry.getValue() instanceof DuccWorkReservation ) {

View Full Code Here

    try {
      StringBuffer sb = new StringBuffer();
      for( Entry<DuccId,IDuccWork> job : workMap.entrySet()) {
        IDuccWork duccWork = job.getValue();
        if ( duccWork instanceof DuccWorkJob ) {
          DuccWorkJob duccWorkJob = (DuccWorkJob)duccWork;
          //  Below should never be null
          IDuccProcess driverProcess =
              duccWorkJob.getDriver().getProcessMap().entrySet().iterator().next().getValue();
          sb.append("\n").append(tbl).
             append("\nJob ID: ").append(duccWorkJob.getDuccId().getFriendly()).
             append("\tJobState: ").append(duccWorkJob.getStateObject()).
             append("\tJobSubmittedBy: ").append(duccWorkJob.getStandardInfo().getUser()).
             append("\n\n").
             append(header).append(tbl).append("\n").
             append(formatProcess(driverProcess));
          
          for(Entry<DuccId,IDuccProcess> process : ((DuccWorkJob)job.getValue()).getProcessMap().entrySet()) {

View Full Code Here

        logger.error(methodName, null, error_message);
        submitError(properties, error_message);
      }
      else {
        if(Validate.request(duccEvent)) {
          DuccWorkJob duccWorkJob = jobFactory.create(common,properties);
          long t0 = System.currentTimeMillis();
          workMap.addDuccWork(duccWorkJob);
          long t1 = System.currentTimeMillis();
          long elapsed = t1 - t0;
          if(elapsed > Constants.SYNC_LIMIT) {
            logger.debug(methodName, null, "elapsed msecs: "+elapsed);
          }
          // state: Received
          stateJobAccounting.stateChange(duccWorkJob, JobState.Received);
          OrchestratorCheckpoint.getInstance().saveState();
          // state: WaitingForDriver
          stateJobAccounting.stateChange(duccWorkJob, JobState.WaitingForDriver);
          OrchestratorCheckpoint.getInstance().saveState();
          // prepare for reply to submitter
          properties.put(JobRequestProperties.key_id, duccWorkJob.getId());
          duccEvent.setProperties(properties);
        }
        else {
          logger.info(methodName, null, messages.fetch("TODO")+" prepare error reply");
          //TODO

View Full Code Here

      submitError(properties, error_message);
    }
    else if(Validate.request(duccEvent)) {
      String jobId = properties.getProperty(JobRequestProperties.key_id);
      long t0 = System.currentTimeMillis();
      DuccWorkJob duccWorkJob = (DuccWorkJob) workMap.findDuccWork(DuccType.Job,jobId);
      long t1 = System.currentTimeMillis();
      long elapsed = t1 - t0;
      if(elapsed > Constants.SYNC_LIMIT) {
        logger.debug(methodName, dwid, "elapsed msecs: "+elapsed);
      }
      if(duccWorkJob != null) {
        dwid = duccWorkJob.getDuccId();
        String reqUser = properties.getProperty(JobRequestProperties.key_user).trim();
        String reqRole = getRole(properties);
        String tgtUser = duccWorkJob.getStandardInfo().getUser().trim();
        if(isAuthorized(dwid, reqUser, tgtUser, reqRole)) {
          logger.debug(methodName, dwid, "reqUser:"+reqUser+" "+"reqRole:"+reqRole+" "+"tgtUser:"+tgtUser);
          String message = "job canceled by userid "+reqUser;
          if(properties.containsKey(SpecificationProperties.key_reason)) {
            String reason = properties.getProperty(SpecificationProperties.key_reason);
            if(reason != null) {
              message += ": "+reason;
            }
          }
          IRationale rationale = new Rationale(message);
          JobCompletionType jobCompletionType = JobCompletionType.CanceledByUser;
          if(reqRole.equals(SpecificationProperties.key_role_administrator)) {
            jobCompletionType = JobCompletionType.CanceledByAdministrator;
          }
          stateManager.jobTerminate(duccWorkJob, jobCompletionType, rationale, ProcessDeallocationType.JobCanceled);
          OrchestratorCheckpoint.getInstance().saveState();
          // prepare for reply to canceler
          properties.put(JobReplyProperties.key_message, JobReplyProperties.msg_canceled);
          duccEvent.setProperties(properties);
          logger.info(methodName, dwid, messages.fetchLabel("job state")+duccWorkJob.getJobState());
        }
        else {
          // prepare not authorized reply 
          properties.put(JobReplyProperties.key_message, JobReplyProperties.msg_user_not_authorized);
          duccEvent.setProperties(properties);

View Full Code Here

      submitError(properties, error_message);
    }
    else if(Validate.request(duccEvent)) {
      String dpid = null;
      String jobId = properties.getProperty(JobRequestProperties.key_id);
      DuccWorkJob duccWorkJob = (DuccWorkJob) workMap.findDuccWork(DuccType.Job,jobId);
      if(duccWorkJob != null) {
        dwid = duccWorkJob.getDuccId();
        String reqUser = properties.getProperty(JobRequestProperties.key_user).trim();
        String reqRole = getRole(properties);
        String tgtUser = duccWorkJob.getStandardInfo().getUser().trim();
        if(isAuthorized(dwid, reqUser, tgtUser, reqRole)) {
          logger.debug(methodName, dwid, "reqUser:"+reqUser+" "+"reqRole:"+reqRole+" "+"tgtUser:"+tgtUser);
          dpid = properties.getProperty(JobReplyProperties.key_dpid);
          IDuccProcess idp = duccWorkJob.getProcess(dpid);
          if(idp != null) {
            switch(idp.getProcessState()) {
            case Starting:
            case Initializing:
            case Running:

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.apache.uima.ducc.transport.event.common.DuccWorkJob

org.apache.uima.ducc.jd.JobDriverComponent

org.apache.uima.ducc.orchestrator.JobFactory

org.apache.uima.ducc.orchestrator.OrchestratorComponent

org.apache.uima.ducc.orchestrator.StateManager

org.apache.uima.ducc.pm.ProcessManagerComponent

org.apache.uima.ducc.sm.ServiceHandler

org.apache.uima.ducc.sm.ServiceManagerComponent

org.apache.uima.ducc.ws.DuccData

org.apache.uima.ducc.ws.DuccDataHelper

org.apache.uima.ducc.ws.Info

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.