source: xssim/trunk/src/test/rewolucja/scheduling/JobRegistry.java @ 104

package test.rewolucja.scheduling;

import gridsim.Gridlet;
import gridsim.gssim.GssimConstants;
import gridsim.gssim.ResourceHistoryItem;
import gridsim.gssim.SubmittedTask;
import gssim.schedframe.scheduling.AbstractExecutable;
import gssim.schedframe.scheduling.ExecTaskInterface;
import gssim.schedframe.scheduling.Executable;
import gssim.schedframe.scheduling.queues.TaskQueue;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTime;

import schedframe.resources.units.ResourceUnit;
import schedframe.scheduling.AbstractProcesses;
import schedframe.scheduling.Job;
import schedframe.scheduling.JobInterface;
import schedframe.scheduling.Task;
import schedframe.scheduling.TaskInterface;
import schedframe.scheduling.utils.ResourceParameterName;
import test.rewolucja.resources.ProcessingElements;
import test.rewolucja.resources.physical.base.ComputingResource;
import test.rewolucja.scheduling.plan.AllocationInterfaceNew;

public class JobRegistry extends AbstractJobRegistry /*implements Cloneable*/ {
        
        private static final long serialVersionUID = 8030555906990767342L;

        private static Log log = LogFactory.getLog(JobRegistry.class);

        private String context;

        protected static final List<ExecTaskInterface> submittedTasks = Collections.synchronizedList(new ArrayList<ExecTaskInterface>());;
        //protected static final List<ExecTaskInterface> submittedTasks = new CopyOnWriteArrayList<ExecTaskInterface>();

        public JobRegistry(String context_) {
                context = context_;
        }

        /*protected void setContext(String context_) {
                context = context_;
        }*/

        public boolean addTask(ExecTaskInterface newTask) {
                if(getSubmittedTask(newTask.getJobId(), newTask.getId()) == null)
                {
                        synchronized (submittedTasks)  {
                                submittedTasks.add(newTask);
                        }
                        return true;
                }
                return false;
        }

        public List<ExecTaskInterface> getTasks(int status) {
                List<ExecTaskInterface> taskList = new ArrayList<ExecTaskInterface>();
                synchronized (submittedTasks)  {
                        for (ExecTaskInterface task : submittedTasks) {
                                if (task.getStatus() == status) {
                                        SubmittedTask subTask = (SubmittedTask) task;
                                        if (subTask.getResPath().contains(context)) {
                                                taskList.add(subTask);
                                        }
                                }
                        }
                }
                return taskList;
        }

        public List<ExecTaskInterface> getQueuedTasks() {
                return getTasks(Gridlet.QUEUED);
        }
        
        public List<ExecTaskInterface> getRunningTasks() {
                return getTasks(Gridlet.INEXEC);
        }
        
        public List<ExecTaskInterface> getReadyTasks() {
                return getTasks(Gridlet.READY);
        }
        
        public List<ExecTaskInterface> getFinishedTasks() {
                return getTasks(Gridlet.SUCCESS);
        }
        
        
        public List<ExecTaskInterface> getAllSubmittedTasks() {
                List<ExecTaskInterface> taskList;;
                synchronized (submittedTasks)  {
                        taskList = new ArrayList<ExecTaskInterface>(submittedTasks);
                }
                return taskList;
        }

        public List<SubmittedTask> getSubmittedTasks() {
                List<SubmittedTask> taskList = new ArrayList<SubmittedTask>();
                synchronized (submittedTasks)  {
                        for (ExecTaskInterface task : submittedTasks) {
                                SubmittedTask subTask = (SubmittedTask) task;
                                if (subTask.getResPath().contains(context)) {
                                        taskList.add(subTask);
                                }
                        }
                }
                return taskList;
        }
        
        public SubmittedTask getSubmittedTask(String jobId, String taskId){
                synchronized (submittedTasks)  {
                        for (ExecTaskInterface task : submittedTasks) {
                                if (task.getJobId().compareTo(jobId) == 0 && task.getId().compareTo(taskId)==0) {
                                        return (SubmittedTask)task;
                                }
                        }
                }
                return null;
        }
        
        public List<TaskInterface<?>> getReadyTasks(List<JobInterface<?>> jobsList) {
                List<TaskInterface<?>> tasks = new ArrayList<TaskInterface<?>>();
                TaskQueue waitingTasks = new TaskQueue();
                
                for(int i = 0; i < jobsList.size(); i++){
                        Job newJob = (Job)jobsList.get(i);
                        waitingTasks.addAll(newJob.getTask());
                }

                tasks.addAll(waitingTasks.getReadyTasks(this));
                return tasks;
        }
        


        public AbstractExecutable getTaskExecutable(Integer executableId){
                synchronized (submittedTasks)  {
                        for (ExecTaskInterface task : submittedTasks) {
                                SubmittedTask subTask = (SubmittedTask) task;
                                AbstractExecutable exec = (AbstractExecutable)subTask.getGridlet();
                                if (exec.getGridletID() == executableId) {
                                        return exec;
                                }
                        }
                }
                return null;
        }
        public List<AbstractExecutable> getJobExecutables(String jobId){
                List<AbstractExecutable> list = new ArrayList<AbstractExecutable>();
                synchronized (submittedTasks)  {
                        for(int i = 0; i < submittedTasks.size(); i++){
                                SubmittedTask subTask = (SubmittedTask) submittedTasks.get(i);
                                AbstractExecutable exec = (AbstractExecutable)subTask.getGridlet();
                                
                                if(exec.getJobId().equals(jobId))
                                        list.add(exec);
                        }
                }
                
                return list;
        }
        
        /*public AbstractExecutable getTaskExecutabls(String jobId, String taskId){
                List<AbstractExecutable> list = new ArrayList<AbstractExecutable>();
                synchronized (submittedTasks)  {
                        for(int i = 0; i < size(); i++){
                                SubmittedTask subTask = (SubmittedTask) submittedTasks.get(i);
                                AbstractExecutable exec = (AbstractExecutable)subTask.getGridlet();
                                
                                if(exec.getJobId().equals(jobId) && exec.getId().equals(taskId))
                                        return exec;
                        }
                }
                return null;
        }*/
        
        
        public Executable createExecutable(Task task, AllocationInterfaceNew allocation) {

                String refersTo = allocation.getProcessGroupId(); // null;//allocation.getRefersTo();
                if(refersTo == null)
                        refersTo = task.getId();
                        
                Executable exec = null;

                if(refersTo.equals(task.getId())){
                        exec = new Executable(task);
                } else {
                        List<AbstractProcesses> processes = task.getProcesses();
                        if(processes == null) {
                                try {
                                        log.error("Allocation: " + allocation.getDocument() + "\nrefers to unknown task or processes set." +
                                                        " Set correct value (task id or prcesses set id) for allocation refersTo attribute.");
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                        boolean found = false;
                        for(int j = 0; j < processes.size() && !found; j++){
                                AbstractProcesses procesesSet = processes.get(j);
                                if(refersTo.equals(procesesSet.getId())){
                                        exec = new Executable(task, procesesSet);
                                        found = true;
                                }
                        }
                        if(!found){
                                log.error("Allocation refers to unknown proceses set.");
                        }
                                
                }
                
                exec.setUserID(task.getSenderId());
                exec.setLength(task.getLength());
                exec.setReservationId(allocation.getReservationId());
                        
                /*HostInterface<?> host = allocation.getHost();
                ComputingResourceTypeInterface<?> crt = host.getMachineParameters();
                if(crt != null){
                        ComputingResourceTypeItemInterface<?> crti = crt.getComputingResourceTypeItem(0);
                        if(crti != null){
                                ParameterPropertyInterface<?> properties[] = crti.getHostParameter().getProperty();
                                for(int p = 0; p < properties.length; p++){
                                        ParameterPropertyInterface<?> property = properties[p];
                                        if("chosenCPUs".equals(property.getName())){
                                                Object cpuNames = property.getValue();
                                                exec.addSpecificResource(ResourceParameterName.FREECPUS, cpuNames);
                                        }
                                }
                        }
                }*/
                return exec;
        }


        /**************************************/
        protected static Map<Integer, Map<String, Object>> history = new HashMap<Integer, Map<String,Object>>();
        
        public static Map<Integer, Map<String, Object>> getAllocationHistory(){
                return history;
        }
        
        public void saveHistory (SubmittedTask submittedTask, int estimatedTime, Map<ResourceParameterName, ResourceUnit> choosenResources){
                
                submittedTask.setEstimatedDuration(estimatedTime);

                DateTime currentTime = new DateTime();
                ResourceHistoryItem resHistItem = new ResourceHistoryItem(choosenResources, currentTime);
                submittedTask.addUsedResources(resHistItem);

                Map<String, Object> historyItem = new HashMap<String, Object>();
                List<ResourceHistoryItem> list = new ArrayList<ResourceHistoryItem>(1);
                list.add(resHistItem);
                historyItem.put(GssimConstants.RESOURCES, list);
                historyItem.put(GssimConstants.START_TIME, currentTime);
                currentTime = currentTime.plusSeconds(estimatedTime);
                historyItem.put(GssimConstants.END_TIME, currentTime);

                submittedTask.setFinishTime(currentTime.getMillis() / 1000);
                
                history.put(Integer.valueOf(submittedTask.getGridletID()), historyItem);
                ProcessingElements pes = (ProcessingElements) choosenResources.get(ResourceParameterName.PROCESSINGELEMENTS);
                for (ComputingResource resource : pes) {
                        submittedTask.addToResPath(resource.getName());
                        ComputingResource parent = resource.getParent();
                        while (parent != null && !submittedTask.getResPath().contains(parent.getName() + "_")) {
                                submittedTask.addToResPath(parent.getName());
                                parent = parent.getParent();
                        }
                }
        }


}