source: DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/tasks/AbstractJobRegistry.java @ 1551

package schedframe.scheduling.manager.tasks;


import gridsim.dcworms.DCWormsTags;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitName;
import schedframe.scheduling.manager.resources.utils.ResourceManagerUtils;
import schedframe.scheduling.tasks.Job;
import schedframe.scheduling.tasks.JobInterface;
import schedframe.scheduling.tasks.Task;
import schedframe.scheduling.tasks.TaskInterface;
import simulator.DataCenterWorkloadSimulator;
import dcworms.schedframe.scheduling.ExecTask;


public abstract class AbstractJobRegistry /*extends ConcurrentHashMap<String, Job>*/ implements JobRegistry{
        
        
        protected static final ConcurrentHashMap<String, JobInterface<?>> jobs = new ConcurrentHashMap<String, JobInterface<?>>();
        
        protected AbstractJobRegistry(){
        }
        
        public boolean addJob(JobInterface<?> job) {
                jobs.put(job.getId(), job);
                return true;
        }

        public boolean addTask(TaskInterface<?> task) {
                if(jobs.containsKey(task.getJobId())){
                        getJob(task.getJobId()).add((Task)task);
                        return true;
                } else {
                        return false;
                }
        }

        public JobInterface<?> getJobInfo(String jobId) {
                return jobs.get(jobId);
        }

        public TaskInterface<?> getTaskInfo(String jobId, String taskId) {
                Task task = null;
                Job job = getJob(jobId);
                
                if(job == null)
                        return null;
                
                try {
                        task = job.getTask(taskId);
                } catch (NoSuchFieldException e) {
                }
                return task;
        }
        
        public Job getJob(String jobId){
                return (Job)jobs.get(jobId);
        }
        
        public List<JobInterface<?>> getJobs(){
                List<JobInterface<?>> jobList = new ArrayList<JobInterface<?>>();
                for(String jobId: jobs.keySet()) {
                        jobList.add(jobs.get(jobId));
                }
                return jobList;
        }

        public List<JobInterface<?>> getJobs(int status) {
                List<JobInterface<?>> jobList = new ArrayList<JobInterface<?>>();
                synchronized (jobs) {
                        for(String jobId: jobs.keySet()){
                                JobInterface<?> job = jobs.get(jobId);
                                if (job.getStatus() == status) {
                                        jobList.add(job);
                                }
                        }
                }
                return jobList;
        }

        @Override
        public boolean pauseTask(String jobId, String taskId) {
                ExecTask execTask = getTask(jobId, taskId);
                if (execTask == null) {
                        return false;
                }else{
                        try {
                                execTask.setStatus(DCWormsTags.PAUSING);
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        String[] ids = new String[2];
                        ids[0] = new String(jobId);
                        ids[1] = new String(taskId);
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.TASK_PAUSE, ids);
                        return true;
                }
        }

        public boolean resumeTask(String jobId, String taskId) {
                ExecTask execTask = getTask(jobId, taskId);
                if (execTask == null) {
                        return false;
                }else{
                        String[] ids = new String[2];
                        ids[0] = new String(jobId);
                        ids[1] = new String(taskId);
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.TASK_RESUME, ids);
                        return true;    
                }
        }

        public boolean migrateTask(String jobId, String taskId, Map<ResourceUnitName, ResourceUnit> choosenResources) {
                ExecTask execTask = getTask(jobId, taskId);
                if (execTask == null) {
                        return false;
                }else{
                        try {
                                execTask.setStatus(DCWormsTags.IN_MIGRATION);
                        } catch (Exception e) {
                                return false;
                        }
                        if(choosenResources != null){
                                ResourceManagerUtils.setPendingResources(choosenResources);
                        }
                        Object[] data = new Object[3];
                        data[0] = new String(jobId);
                        data[1] = new String(taskId);
                        data[2] = choosenResources;
                        DataCenterWorkloadSimulator.getEventManager().sendToScheduler(execTask.getSchedulerName(), 0, DCWormsTags.TASK_MIGRATE, data);
                        return true;    
                }
        }

        public boolean migrateTask(String jobId, String taskId, String nodeName) {
                // TODO Auto-generated method stub
                return false;
        }
        
}