source: DCWoRMS/trunk/src/test/stress/TasksExperimentsGenerator.java @ 477

package test.stress;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Map.Entry;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import simulator.workload.generator.WorkloadGenerator;
import simulator.workload.reader.archive.swf.SWFParser;
import simulator.workload.writer.swf.QcgSWFJobWriter;

/**
 * Class responsible for generating experiments based on amount and range of
 * tasks.
 * 
 * @author Jarek Szymczak
 * @version $Id$
 */
public class TasksExperimentsGenerator extends AbstractExperimentsGenerator {

        /** Class logger. */
        private static final Log LOGGER =
                        LogFactory.getLog(TasksExperimentsGenerator.class);

        /**
         * It runs the resource range / values based generation
         * 
         * @param args
         *            the following arguments (other are not allowed - arguments
         *            predecessed by "#" are integers):
         *            <ul>
         *            <li><b>-g #start #step #end</b> - experiments with tasks
         *            range from #start to #end with step #step will be generated
         *            <li><b>-v #tasks_1 ... #tasks_n</b> - experiments with
         *            #tasks_1, ..., #tasks_n number of tasks will be generated
         *            </ul>
         * @return path to directory containing generated experiments
         * @throws FileNotFoundException
         *             one of necessary files was not found
         * @throws IOException
         *             signals that an I/O exception has occurred
         */
        public String run(String args[]) throws FileNotFoundException, IOException {

                long max = 0;
                long[] values = null;

                if (args[0].equals("-g")) {

                        long start = Long.parseLong(args[1]);
                        long step = Long.parseLong(args[2]);
                        max = Long.parseLong(args[3]);

                        values =
                                        new long[(int) Math.ceil((double) (max - start)
                                                        / (double) step)];
                        int i = 0;
                        for (long j = start; j < max; j += step) {
                                values[i++] = j;
                        }
                } else if (args[0].equals("-v")) {
                        values = new long[args.length - 2];
                        for (int i = 1; i < args.length - 1; i++)
                                values[i - 1] = Long.parseLong(args[i]);
                        max = Long.parseLong(args[args.length - 1]);
                } else {
                        throw new RuntimeException("Class must be launched with -v or -g");
                }

                LOGGER.info("Generating workload from range: "
                                + Long.toString(values[0]) + "-" + Long.toString(max));

                Properties variables = new Properties();
                FileInputStream fis = null;
                try {
                        fis =
                                        new FileInputStream(new File(
                                                        "properties/variables.properties"));
                        variables.load(fis);
                } catch (FileNotFoundException e) {
                        LOGGER
                                        .error("Could not find variables.properties file, application will terminate!");
                        throw new RuntimeException(e);
                } catch (IOException e) {
                        LOGGER
                                        .error("Problems with I/O operations while trying to load variables.properties file, application will terminate!");
                        throw new RuntimeException(e);
                } finally {
                        try {
                                if (fis != null)
                                        fis.close();
                        } catch (IOException e) {
                                LOGGER
                                                .error("An error occured while closing the stream with variables");
                        }
                }

                variables.setProperty("MAX_TASKS_NO", Long.toString(max));

                createFileFromTemplate("properties/generator_template.properties",
                                "properties/generator.properties", variables);
                createFileFromTemplate("properties/generator_template.xml",
                                "properties/generator.xml", variables);

                deleteDirectory(new File(variables.getProperty("EXP_PATH")));

                File dir =
                                new File(variables.getProperty("EXP_PATH") + "/"
                                                + variables.getProperty("MAX_TASKS_NO"));

                if (!dir.exists()) {
                        try {
                                dir.mkdirs();
                        } catch (SecurityException e) {
                                LOGGER
                                                .error("Security violation while trying to create directories: "
                                                                + dir.getAbsolutePath() + "!");
                        }
                }

                String parameters[] = { "properties/generator.properties" };
                WorkloadGenerator.main(parameters); // deleteDirectory(new File("raz"));
                LOGGER.info("Dividing max number of tasks among other values");
                for (long i : values) {

                        LOGGER.debug("Workload with " + Long.toString(i)
                                        + " tasks is about to be truncated");
                        variables.setProperty("TASKS_NO", Long.toString(i));

                        copyFiles(i, variables.getProperty("EXP_PATH") + "/"
                                        + variables.getProperty("MAX_TASKS_NO"), variables
                                        .getProperty("EXP_PATH")
                                        + "/" + variables.getProperty("TASKS_NO"), variables);

                        truncWorkloadFile(i, variables.getProperty("EXP_PATH") + "/"
                                        + variables.getProperty("MAX_TASKS_NO") + "/"
                                        + variables.getProperty("WORKLOAD_FILENAME"), variables
                                        .getProperty("EXP_PATH")
                                        + "/"
                                        + variables.getProperty("TASKS_NO")
                                        + "/"
                                        + variables.getProperty("WORKLOAD_FILENAME"));

                        int zeroes =
                                        variables.getProperty("MAX_TASKS_NO").length()
                                                        - variables.getProperty("TASKS_NO").length();
                        StringBuilder expPropertiesNo = new StringBuilder();
                        for (int j = 0; j < zeroes; j++)
                                expPropertiesNo.append('0');
                        expPropertiesNo.append(variables.getProperty("TASKS_NO"));
                        expPropertiesNo.append(".properties");

                        createFileFromTemplate(
                                        "properties/reservation_template.properties", variables
                                                        .getProperty("EXP_PATH")
                                                        + "/" + expPropertiesNo.toString(), variables);
                        LOGGER.debug("Workload with " + Long.toString(i)
                                        + " tasks truncating finished");
                }

                variables
                                .setProperty("TASKS_NO", variables.getProperty("MAX_TASKS_NO"));

                createFileFromTemplate("properties/reservation_template.properties",
                                variables.getProperty("EXP_PATH") + "/"
                                                + variables.getProperty("TASKS_NO") + ".properties",
                                variables);

                LOGGER.info("Division of tasks finished");

                return variables.getProperty("EXP_PATH");
        }

        /**
         * It truncates workload file.
         * 
         * @param numberOfExperiments
         *            the number of experiments contained in originalWorkloadPath to
         *            save in truncWorkloadPath
         * @param originalWorkloadPath
         *            the original workload path
         * @param truncWorkloadPath
         *            the truncated workload path
         * @throws IOException
         *             Signals that an I/O exception has occurred.
         */
        private void truncWorkloadFile(long numberOfExperiments,
                        String originalWorkloadPath, String truncWorkloadPath)
                        throws IOException {

                SWFParser swfParser = null;
                QcgSWFJobWriter jobWriter = null;

                try {
                        swfParser = new SWFParser(originalWorkloadPath);
                        File temp = new File(truncWorkloadPath);
                        jobWriter = new QcgSWFJobWriter(temp.getParent(), temp.getName());

                        Map<String, String> header = swfParser.loadHeader();
                        Set<Entry<String, String>> commentsEntrySet = header.entrySet();
                        header.entrySet();

                        for (Entry<String, String> entry : commentsEntrySet) {
                                jobWriter.writeComment(entry.getKey(), entry.getValue());
                        }

                        Map<String, String[]> mapping = swfParser.getIDMapping();
                        String[] singleJob = null;
                        String[] singleJobMapping = null;

                        for (long i = 0; i < numberOfExperiments; i++) {
                                singleJob = swfParser.readTask();
                                singleJobMapping = mapping.get(Long.toString(i));

                                jobWriter.writeLine(singleJob);
                                jobWriter.addTaskMapping(Long.toString(i), singleJobMapping[0],
                                                singleJobMapping[1]);
                        }

                } finally {
                        if (swfParser != null)
                                swfParser.close();
                        if (jobWriter != null)
                                jobWriter.close();
                }

        }
}