source: DCWoRMS/trunk/src/schedframe/scheduling/tasks/SubmittedTask.java @ 477

package schedframe.scheduling.tasks;

import gridsim.GridSim;
import gridsim.Gridlet;
import gridsim.ResGridlet;
import gssim.schedframe.scheduling.ExecTask;
import gssim.schedframe.scheduling.Executable;

import java.util.List;

import org.apache.commons.lang.ArrayUtils;
import org.joda.time.DateTime;
import org.joda.time.DateTimeUtilsExt;
import org.joda.time.ReadableDuration;

import schedframe.resources.computing.ComputingResource;
import schedframe.resources.units.ProcessingElements;
import schedframe.resources.units.StandardResourceUnitName;
import schedframe.scheduling.ResourceHistoryItem;
import schedframe.scheduling.UsedResourceList;
import schedframe.scheduling.WorkloadUnitHandler;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;
import schedframe.scheduling.tasks.requirements.ResourceParameterName;

/**
 * 
 * @author Marcin Krystek
 *
 */
public class SubmittedTask extends ResGridlet implements ExecTask{

        protected Executable task;
        protected int estimatedDuration;
        protected UsedResourceList<ResourceHistoryItem> usedResources;
        //protected List<String> visitedResources;
        
        public SubmittedTask(Executable exec) {
                super(exec);
                task = exec;
                this.usedResources = new UsedResourceList<ResourceHistoryItem>();
                if(exec.requireReservation())
                        this.reservID_ = Integer.valueOf(exec.getReservationId());
                //this.visitedResources = new ArrayList<String>();
        }

        public double getCpuCntRequest() throws NoSuchFieldException {
                return task.getCpuCntRequest();
        }

        public DateTime getExecutionEndTime() throws NoSuchFieldException {
                return task.getExecutionEndTime();
        }

        public DateTime getExecutionStartTime() throws NoSuchFieldException {
                return task.getExecutionStartTime();
        }

        public ReadableDuration getExpectedDuration() throws NoSuchFieldException {
                return task.getExpectedDuration();
        }

        public int getEstimatedDuration(){
                return this.estimatedDuration;
        }
        
        public void setEstimatedDuration(int value){
                this.estimatedDuration = value;
        }
        
        public String getId() {
                return task.getId();
        }

        public String getJobId() {
                return task.getJobId();
        }

        public long getLength() {
                return task.getLength();
        }

        public double getMemoryRequest() throws NoSuchFieldException {
                return task.getMemoryRequest();
        }

        public double getParameterDoubleValue(ResourceParameterName parameterName)
                        throws NoSuchFieldException, IllegalArgumentException {
                return task.getParameterDoubleValue(parameterName);
        }

        public String getParameterStringValue(ResourceParameterName parameterName)
                        throws NoSuchFieldException, IllegalArgumentException {
                return task.getParameterStringValue(parameterName);
        }

        public List<AbstractProcessesGroup> getProcessesGroups() {
                throw new RuntimeException("Not implemented");
        }
        
        public List<AbstractProcesses> getProcesses(){
                throw new RuntimeException("Not implemented");
        }
        
        public List<AbstractProcesses> getProcesses(AbstractProcessesGroup processGroup){
                throw new RuntimeException("Not implemented");
        }

        public int getStatus() {
                return task.getStatus();
        }

        public DateTime getSubmissionTimeToBroker() {
                return task.getSubmissionTimeToBroker();
        }

        public String getUserDn() {
                return task.getUserDn();
        }

        public void setLength(long length) {
                throw new RuntimeException("Task length should not be changed here.");
        }

        public void setStatus(int status) throws Exception {
                task.setStatus(status);
        }

        public org.qcg.broker.schemas.resreqs.Task getDescription() {
                return (org.qcg.broker.schemas.resreqs.Task) task.getDescription();
        }

        public String getDocument() throws Exception {
                return task.getDocument();
        }
        
        public boolean expectSpecificResource(ResourceParameterName resourceName){
                return task.expectSpecificResource(resourceName);
        }
        
        public Object getExpectedSpecificResource(ResourceParameterName resourceName){
                return task.getExpectedSpecificResource(resourceName);
        }

        public long getWorkloadLogWaitTime() {
                return task.getWorkloadLogWaitTime();
        }
        
        public void addUsedResources(ResourceHistoryItem usedResources){
                this.usedResources.add(usedResources);
        }
        
        //public List<Map<ResourceParameterName, ResourceUnit>> getUsedResources(){
        public UsedResourceList<ResourceHistoryItem> getUsedResources(){
                return this.usedResources;
        }
        
        public boolean setGridletStatus(int status)
    {
        // gets Gridlet's previous status
        int prevStatus = gridlet_.getGridletStatus();

        // if the status of a Gridlet is the same as last time, then ignore
        if (prevStatus == status) {
            return false;
        }

        boolean success = true;
        try
        {
            double clock = GridSim.clock();   // gets the current clock
            long sec = DateTimeUtilsExt.currentTimeMillis() / 1000; // time in seconds 
            clock = Long.valueOf(sec).doubleValue();
            
            // sets Gridlet's current status
            gridlet_.setGridletStatus(status);

            // if a previous Gridlet status is INEXEC
            if (prevStatus == Gridlet.INEXEC)
            {
                // and current status is either CANCELED, PAUSED or SUCCESS
                if (status == Gridlet.CANCELED || status == Gridlet.PAUSED ||
                    status == Gridlet.SUCCESS)
                {
                    // then update the Gridlet completion time
                    totalCompletionTime_ += (clock - startExecTime_);
                    index_ = 0;
                    return true;
                }
            }

            if (prevStatus == Gridlet.RESUMED && status == Gridlet.SUCCESS)
            {
                // then update the Gridlet completion time
                totalCompletionTime_ += (clock - startExecTime_);
                return true;
            }

            // if a Gridlet is now in execution
            if (status == Gridlet.INEXEC ||
                (prevStatus == Gridlet.PAUSED && status == Gridlet.RESUMED) )
            {
                
                startExecTime_ = clock;
                gridlet_.setExecStartTime(startExecTime_);
                        ProcessingElements pes = (ProcessingElements) getUsedResources().getLast().getResourceUnits().get(StandardResourceUnitName.PE);
                        for (ComputingResource resource : pes) {

                                visitResource(resource.getName());
                                ComputingResource parent = resource.getParent();

                                        List<String> visitedResource = getVisitedResources();
                                while (parent != null && !ArrayUtils.contains(visitedResource.toArray(new String[visitedResource.size()]), parent.getName())) {
                                        visitResource(parent.getName());
                                        parent = parent.getParent();
                                }
                        }
            }
        }
        catch(Exception e) {
            success = false;
        }

        return success;
    }
        
        
        protected void init() {
                super.init();
                double time =  DateTimeUtilsExt.getDateTimeAt(arrivalTime_).getMillis() / 1000;
                this.gridlet_.setSubmissionTime(time);
         }


        @Override
        public boolean isFinished() {
                // TODO Auto-generated method stub
                return false;
        }
        
        /*public void addToResPath(String resName){
                task.addToResPath(resName);
        }
        
        public String getResPath(){
                return task.getResPath();
        }*/
        
        public void visitResource(String resName){
                task.visitResource(resName);
        }
        
        public List<String> getVisitedResources(){
                return task.getVisitedResources();
        }
        
        public boolean isRegistered() {
                return task.isRegistered();
        }

        public void register(JobRegistryImpl jobRegistry) {
                task.register(jobRegistry);
                //jobRegistry.addTask(this);
        }
        
        @Override
        public void accept(WorkloadUnitHandler wuh) {
                wuh.handleSubmittedTask(this);
        }
}