Example usage for java.lang Process Process

List of usage examples for java.lang Process Process

Introduction

In this page you can find the example usage for java.lang Process Process.

Prototype

public Process() 

Source Link

Document

Default constructor for Process.

Usage

From source file:de.prozesskraft.pkraft.Createdoc.java

public static void main(String[] args) throws org.apache.commons.cli.ParseException, IOException {

    Createdoc tmp = new Createdoc();
    /*----------------------------
      get options from ini-file/*w w  w  .  j ava2s. c o m*/
    ----------------------------*/
    File installDir = new java.io.File(WhereAmI.getInstallDirectoryAbsolutePath(Createdoc.class) + "/..");

    File inifile = new java.io.File(installDir.getAbsolutePath() + "/etc/pkraft-createdoc.ini");

    if (inifile.exists()) {
        try {
            ini = new Ini(inifile);
        } catch (InvalidFileFormatException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    } else {
        System.err.println("ini file does not exist: " + inifile.getAbsolutePath());
        System.exit(1);
    }

    /*----------------------------
      create boolean options
    ----------------------------*/
    Option ohelp = new Option("help", "print this message");
    Option ov = new Option("v", "prints version and build-date");

    /*----------------------------
      create argument options
    ----------------------------*/
    Option odefinition = OptionBuilder.withArgName("definition").hasArg()
            .withDescription("[mandatory] process definition file")
            //            .isRequired()
            .create("definition");

    Option oformat = OptionBuilder.withArgName("format").hasArg()
            .withDescription("[mandatory, default=pdf] output format (pdf|pptx) ").create("format");

    Option ooutput = OptionBuilder.withArgName("output").hasArg().withDescription(
            "[mandatory, default=out.<format>] output file with full documentation of process definition")
            //            .isRequired()
            .create("output");

    ////      Option property = OptionBuilder.withArgName( "property=value" )
    ////            .hasArgs(2)
    ////            .withValueSeparator()
    ////            .withDescription( "use value for given property" )
    ////            .create("D");
    //      
    //      /*----------------------------
    //        create options object
    //      ----------------------------*/
    Options options = new Options();

    options.addOption(ohelp);
    options.addOption(ov);
    options.addOption(odefinition);
    options.addOption(oformat);
    options.addOption(ooutput);

    /*----------------------------
      create the parser
    ----------------------------*/
    CommandLineParser parser = new GnuParser();
    // parse the command line arguments
    line = parser.parse(options, args);

    /*----------------------------
      usage/help
    ----------------------------*/
    if (line.hasOption("help")) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("createdoc", options);
        System.exit(0);
    }

    if (line.hasOption("v")) {
        System.out.println("web:     www.prozesskraft.de");
        System.out.println("version: [% version %]");
        System.out.println("date:    [% date %]");
        System.exit(0);
    }

    /*----------------------------
      die variablen festlegen
    ----------------------------*/
    int error = 0;
    String definition = null;
    String format = null;
    String output = null;

    // festlegen von definition
    if (line.hasOption("definition")) {
        definition = line.getOptionValue("definition");
        if (!(new java.io.File(definition).exists())) {
            System.err.println("file does not exist " + definition);
        }
    } else {
        System.err.println("parameter -definition is mandatory");
        error++;
    }

    // festlegen von format
    if (line.hasOption("format")) {
        if (line.getOptionValue("format").matches("pdf|pptx")) {
            format = line.getOptionValue("format");
        } else {
            System.err.println("for -format use only pdf|pptx");
            error++;
        }
    } else {
        format = "pdf";
    }

    // festlegen von output
    if (line.hasOption("output")) {
        output = line.getOptionValue("output");
    } else {
        output = "out." + format;
    }

    // feststellen ob output bereits existiert
    if (new java.io.File(output).exists()) {
        System.err.println("output already exists: " + output);
        error++;
    }

    // aussteigen, falls fehler aufgetaucht sind
    if (error > 0) {
        System.err.println("error(s) occured. try -help for help.");
        System.exit(1);
    }

    /*----------------------------
      die lizenz ueberpruefen und ggf abbrechen
    ----------------------------*/

    // check for valid license
    ArrayList<String> allPortAtHost = new ArrayList<String>();
    allPortAtHost.add(ini.get("license-server", "license-server-1"));
    allPortAtHost.add(ini.get("license-server", "license-server-2"));
    allPortAtHost.add(ini.get("license-server", "license-server-3"));

    MyLicense lic = new MyLicense(allPortAtHost, "1", "user-edition", "0.1");

    // lizenz-logging ausgeben
    for (String actLine : (ArrayList<String>) lic.getLog()) {
        System.err.println(actLine);
    }

    // abbruch, wenn lizenz nicht valide
    if (!lic.isValid()) {
        System.exit(1);
    }

    /*----------------------------
      die eigentliche business logic
    ----------------------------*/

    Process process = new Process();
    Reporter report;

    process.setInfilexml(definition);

    System.out.println("info: reading process definition " + definition);

    try {
        process.readXml();
        process.setStepRanks();
    }

    catch (JAXBException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    //festlegen des temporaeren verzeichnisses fuer die Daten und Pfade erzeugen
    long jetztMillis = System.currentTimeMillis();
    String randomPathJasperFilled = "/tmp/" + jetztMillis + "_jasperFilled";
    String randomPathPng = "/tmp/" + jetztMillis + "_png";
    String randomPathPdf = "/tmp/" + jetztMillis + "_pdf";
    String randomPathPptx = "/tmp/" + jetztMillis + "_pptx";

    new File(randomPathJasperFilled).mkdirs();
    new File(randomPathPng).mkdirs();
    new File(randomPathPdf).mkdirs();
    new File(randomPathPptx).mkdirs();

    //////////////////////////////////////////

    // erstellen der Bilder

    // konfigurieren der processing ansicht
    //      PmodelViewPage page = new PmodelViewPage(process);
    PmodelViewPage page = new PmodelViewPage();
    page.einstellungen.getProcess().setStepRanks();
    page.einstellungen.setSize(100);
    page.einstellungen.setZoom(100);
    //      page.einstellungen.setZoom(8 * 100/process.getMaxLevel());
    page.einstellungen.setTextsize(0);
    page.einstellungen.setRanksize(7);
    page.einstellungen.setWidth(2500);
    page.einstellungen.setHeight(750);
    page.einstellungen.setGravx(10);
    page.einstellungen.setGravy(0);
    page.einstellungen.setRootpositionratiox((float) 0.05);
    page.einstellungen.setRootpositionratioy((float) 0.5);
    page.einstellungen.setProcess(process);

    createContents(page);

    // mit open kann die page angezeigt werden
    if (!(produktiv)) {
        open();
    }

    //      // warten
    //      System.out.println("stabilisierung ansicht: 5 sekunden warten gravitation = "+page.einstellungen.getGravx());
    //      long jetzt5 = System.currentTimeMillis();
    //      while (System.currentTimeMillis() < jetzt5 + 5000)
    //      {
    //         
    //      }
    //
    //      page.einstellungen.setGravx(10);
    //
    // warten
    int wartezeitSeconds = 1;
    if (produktiv) {
        wartezeitSeconds = page.einstellungen.getProcess().getStep().size() * 2;
    }
    System.out.println("stabilisierung ansicht: " + wartezeitSeconds + " sekunden warten gravitation = "
            + page.einstellungen.getGravx());
    long jetzt6 = System.currentTimeMillis();
    while (System.currentTimeMillis() < jetzt6 + (wartezeitSeconds * 1000)) {

    }

    page.einstellungen.setFix(true);

    // VORBEREITUNG) bild speichern
    processTopologyImagePath = randomPathPng + "/processTopology.png";
    page.savePic(processTopologyImagePath);
    // zuerst 1 sekunde warten, dann autocrop
    long jetzt = System.currentTimeMillis();
    while (System.currentTimeMillis() < jetzt + 1000) {

    }
    new AutoCropBorder(processTopologyImagePath);

    // VORBEREITUNG) fuer jeden step ein bild speichern
    for (Step actualStep : process.getStep()) {

        // root ueberspringen
        //         if (actualStep.isRoot());

        String stepImagePath = randomPathPng + "/step_" + actualStep.getName() + "_Topology.png";

        // Farbe des Steps auf finished (gruen) aendern
        page.einstellungen.getProcess().getRootStep().setStatusOverwrite("waiting");
        actualStep.setStatusOverwrite("finished");

        // etwas warten, bis die farbe bezeichnet wurde
        long jetzt4 = System.currentTimeMillis();
        while (System.currentTimeMillis() < jetzt4 + 500) {

        }

        page.savePic(stepImagePath);
        // zuerst 1 sekunde warten, dann autocrop
        long jetzt3 = System.currentTimeMillis();
        while (System.currentTimeMillis() < jetzt3 + 1000) {

        }
        new AutoCropBorder(stepImagePath);

        stepTopologyImagePath.put(actualStep.getName(), stepImagePath);

        // farbe wieder auf grau aendern
        actualStep.setStatusOverwrite(null);

        System.out.println("erstelle bild fuer step: " + actualStep.getName());

        long jetzt2 = System.currentTimeMillis();
        while (System.currentTimeMillis() < jetzt2 + 1000) {

        }
    }

    page.destroy();

    //////////////////////////////////////////
    report = new Reporter();

    // P03) erstellen des p03
    System.out.println("info: generating p03.");

    String pdfPathP03 = null;
    String pptxPathP03 = null;
    String jasperPathP03 = null;
    String jasperFilledPathP03 = null;

    // P03) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p03") != null) {
        pdfPathP03 = randomPathPdf + "/p03.pdf";
        pptxPathP03 = randomPathPptx + "/p03.pptx";
        jasperPathP03 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p03");
        jasperFilledPathP03 = (randomPathJasperFilled + "/p03.jasperFilled");

        pdfRankFiles.put("0.0.03", pdfPathP03);
        pptxRankFiles.put("0.0.03", pptxPathP03);
    } else {
        System.err.println("no entry 'p03' found in ini file");
        System.exit(1);
    }

    DateFormat dateFormat = new SimpleDateFormat("dd. MM. yyyy");
    Date date = new Date();

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processDatum", dateFormat.format(date));
    report.setParameter("processArchitectLogoImagePath",
            installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "logo"));
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    try {
        report.fillReportFileToFile(jasperPathP03, jasperFilledPathP03);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP03, pdfPathP03);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP03, pptxPathP03);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //System.exit(0);

    //////////////////////////////////////////
    report = new Reporter();

    // P05) erstellen des p05
    System.out.println("info: generating p05.");

    String pdfPathP05 = null;
    String pptxPathP05 = null;
    String jasperPathP05 = null;
    String jasperFilledPathP05 = null;

    // P05) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p05") != null) {
        pdfPathP05 = randomPathPdf + "/p05.pdf";
        pptxPathP05 = randomPathPptx + "/p05.pptx";
        jasperPathP05 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p05");
        jasperFilledPathP05 = (randomPathJasperFilled + "/p05.jasperFilled");

        pdfRankFiles.put("0.0.05", pdfPathP05);
        pptxRankFiles.put("0.0.05", pptxPathP05);
    }

    else {
        System.err.println("no entry 'p05' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    try {
        report.fillReportFileToFile(jasperPathP05, jasperFilledPathP05);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP05, pdfPathP05);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP05, pptxPathP05);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //System.exit(0);

    //////////////////////////////////////////
    report = new Reporter();

    // P08) erstellen des p08
    System.out.println("info: generating p08.");

    String pdfPathP08 = null;
    String pptxPathP08 = null;
    String jasperPathP08 = null;
    String jasperFilledPathP08 = null;

    // P08) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p08") != null) {
        pdfPathP08 = randomPathPdf + "/p08.pdf";
        pptxPathP08 = randomPathPptx + "/p08.pptx";
        jasperPathP08 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p08");
        jasperFilledPathP08 = (randomPathJasperFilled + "/p08.jasperFilled");

        pdfRankFiles.put("0.0.08", pdfPathP08);
        pptxRankFiles.put("0.0.08", pptxPathP08);
    } else {
        System.err.println("no entry 'p08' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());
    report.setParameter("processDescription", process.getDescription());

    try {
        report.fillReportFileToFile(jasperPathP08, jasperFilledPathP08);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP08, pdfPathP08);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP08, pptxPathP08);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //System.exit(0);

    //////////////////////////////////////////

    report = new Reporter();

    // P10) erstellen des p10
    System.out.println("info: generating p10.");

    String pdfPathP10 = null;
    String pptxPathP10 = null;
    String jasperPathP10 = null;
    String jasperFilledPathP10 = null;

    // P10) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p10") != null) {
        pdfPathP10 = randomPathPdf + "/p10.pdf";
        pptxPathP10 = randomPathPptx + "/p10.pptx";
        jasperPathP10 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p10");
        jasperFilledPathP10 = (randomPathJasperFilled + "/p10.jasperFilled");

        pdfRankFiles.put("0.0.10", pdfPathP10);
        pptxRankFiles.put("0.0.10", pptxPathP10);
    } else {
        System.err.println("no entry 'p10' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    // rootstep holen
    Step rootStep = process.getStep(process.getRootstepname());

    // ueber alle commit iterieren
    for (Commit actualCommit : rootStep.getCommit()) {

        // ueber alle files iterieren
        for (de.prozesskraft.pkraft.File actualFile : actualCommit.getFile()) {
            HashMap<String, Object> row = new HashMap<String, Object>();

            // Spalte 'origin'
            row.put("origin", "user/cb2");

            // Spalte 'objectType'
            row.put("objectType", "file");

            // Spalte 'minOccur'
            row.put("minOccur", "" + actualFile.getMinoccur());

            // Spalte 'maxOccur'
            row.put("maxOccur", "" + actualFile.getMaxoccur());

            // Spalte 'objectKey'
            row.put("objectKey", actualFile.getKey());

            // die steps herausfinden, die dieses file benoetigen
            ArrayList<Step> allStepsThatNeedThisFileFromRoot = process.getStepWhichNeedFromRoot("file",
                    actualFile.getKey());
            String stepnameListe = "";
            for (Step actStep : allStepsThatNeedThisFileFromRoot) {
                stepnameListe += "\n=> " + actStep.getName();
            }

            // Spalte 'objectDescription'
            row.put("objectDescription", actualFile.getDescription() + stepnameListe);

            // Datensatz dem report hinzufuegen
            report.addField(row);
        }

        // ueber alle variablen iterieren
        for (de.prozesskraft.pkraft.Variable actualVariable : actualCommit.getVariable()) {
            HashMap<String, Object> row = new HashMap<String, Object>();

            // Spalte 'origin'
            row.put("origin", "user/cb2");

            // Spalte 'objectType'
            row.put("objectType", "variable");

            // Spalte 'minOccur'
            row.put("minOccur", "" + actualVariable.getMinoccur());

            // Spalte 'maxOccur'
            row.put("maxOccur", "" + actualVariable.getMaxoccur());

            // Spalte 'objectKey'
            row.put("objectKey", actualVariable.getKey());

            // die steps herausfinden, die dieses file benoetigen
            ArrayList<Step> allStepsThatNeedThisObjectFromRoot = process.getStepWhichNeedFromRoot("variable",
                    actualVariable.getKey());
            String stepnameListe = "";
            for (Step actStep : allStepsThatNeedThisObjectFromRoot) {
                stepnameListe += "\n=> " + actStep.getName();
            }

            // Spalte 'objectDescription'
            row.put("objectDescription", actualVariable.getDescription() + stepnameListe);

            // Datensatz dem report hinzufuegen
            report.addField(row);
        }

    }

    try {
        report.fillReportFileToFile(jasperPathP10, jasperFilledPathP10);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP10, pdfPathP10);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP10, pptxPathP10);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //////////////////////////////////////////

    report = new Reporter();

    // P20) erstellen des p20
    System.out.println("info: generating p20.");

    String pdfPathP20 = null;
    String pptxPathP20 = null;
    String jasperPathP20 = null;
    String jasperFilledPathP20 = null;

    // P20) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p20") != null) {
        pdfPathP20 = randomPathPdf + "/p20.pdf";
        pptxPathP20 = randomPathPptx + "/p20.pptx";
        jasperPathP20 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p20");
        jasperFilledPathP20 = (randomPathJasperFilled + "/p20.jasperFilled");

        pdfRankFiles.put("0.0.20", pdfPathP20);
        pptxRankFiles.put("0.0.20", pptxPathP20);
    } else {
        System.err.println("no entry 'p20' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    // ueber alle steps iterieren (ausser root)
    for (Step actualStep : (ArrayList<Step>) process.getStep()) {

        // ueberspringen wenn es sich um root handelt
        if (!(actualStep.getName().equals(process.getRootstepname()))) {
            // ueber alle commit iterieren
            for (Commit actualCommit : actualStep.getCommit()) {

                // nur die, die toroot=true ( und spaeter auch tosdm=true)
                if (actualCommit.isTorootPresent()) {
                    // ueber alle files iterieren
                    for (de.prozesskraft.pkraft.File actualFile : actualCommit.getFile()) {

                        HashMap<String, Object> row = new HashMap<String, Object>();

                        // Spalte 'destination'
                        row.put("destination", "user/cb2");

                        // Spalte 'objectType'
                        row.put("objectType", "file");

                        // Spalte 'minOccur'
                        row.put("minOccur", "" + actualFile.getMinoccur());

                        // Spalte 'maxOccur'
                        row.put("maxOccur", "" + actualFile.getMaxoccur());

                        // Spalte 'objectKey'
                        row.put("objectKey", actualFile.getKey());

                        // Spalte 'objectDescription'
                        row.put("objectDescription",
                                actualFile.getDescription() + "\n<= " + actualStep.getName());

                        // Datensatz dem report hinzufuegen
                        report.addField(row);
                    }

                    // ueber alle variablen iterieren
                    for (de.prozesskraft.pkraft.Variable actualVariable : actualCommit.getVariable()) {
                        HashMap<String, Object> row = new HashMap<String, Object>();

                        // Spalte 'objectType'
                        row.put("destination", "user/cb2");

                        // Spalte 'objectType'
                        row.put("objectType", "variable");

                        // Spalte 'minOccur'
                        row.put("minOccur", "" + actualVariable.getMinoccur());

                        // Spalte 'maxOccur'
                        row.put("maxOccur", "" + actualVariable.getMaxoccur());

                        // Spalte 'objectKey'
                        row.put("objectKey", actualVariable.getKey());

                        // Spalte 'objectDescription'
                        row.put("objectDescription",
                                actualVariable.getDescription() + "\n<= " + actualStep.getName());

                        // Datensatz dem report hinzufuegen
                        report.addField(row);
                    }
                }
            }
        }

    }

    try {
        report.fillReportFileToFile(jasperPathP20, jasperFilledPathP20);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP20, pdfPathP20);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP20, pptxPathP20);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //////////////////////////////////////////

    report = new Reporter();

    // P30) erstellen des p30
    System.out.println("info: generating p30.");

    String pdfPathP30 = null;
    String pptxPathP30 = null;
    String jasperPathP30 = null;
    String jasperFilledPathP30 = null;

    // P30) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p30") != null) {
        pdfPathP30 = randomPathPdf + "/p30.pdf";
        pptxPathP30 = randomPathPptx + "/p30.pptx";
        jasperPathP30 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p30");
        jasperFilledPathP30 = (randomPathJasperFilled + "/p30.jasperFilled");

        pdfRankFiles.put("0.0.30", pdfPathP30);
        pptxRankFiles.put("0.0.30", pptxPathP30);
    } else {
        System.err.println("no entry 'p30' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    // P1) bild an report melden
    report.setParameter("processTopologyImagePath", processTopologyImagePath);

    try {
        report.fillReportFileToFile(jasperPathP30, jasperFilledPathP30);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP30, pdfPathP30);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP30, pptxPathP30);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //      System.exit(0);
    //////////////////////////////////////////

    report = new Reporter();

    // P40) erstellen des p40
    System.out.println("info: generating p40.");

    String pdfPathP40 = null;
    String pptxPathP40 = null;
    String jasperPathP40 = null;
    String jasperFilledPathP40 = null;

    // P40) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
    if (ini.get("pkraft-createdoc", "p40") != null) {
        pdfPathP40 = randomPathPdf + "/p40.pdf";
        pptxPathP40 = randomPathPptx + "/p40.pptx";
        jasperPathP40 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p40");
        jasperFilledPathP40 = (randomPathJasperFilled + "/p40.jasperFilled");

        pdfRankFiles.put("0.0.40", pdfPathP40);
        pptxRankFiles.put("0.0.40", pptxPathP40);
    } else {
        System.err.println("no entry 'p40' found in ini file");
        System.exit(1);
    }

    report.setParameter("processName", process.getName());
    report.setParameter("processVersion", process.getVersion());
    report.setParameter("processArchitectCompany", process.getArchitectCompany());
    report.setParameter("processArchitectName", process.getArchitectName());
    report.setParameter("processArchitectMail", process.getArchitectMail());
    report.setParameter("processCustomerCompany", process.getCustomerCompany());
    report.setParameter("processCustomerName", process.getCustomerName());
    report.setParameter("processCustomerMail", process.getCustomerMail());

    // P40) bild an report melden
    report.setParameter("processTopologyImagePath", processTopologyImagePath);

    // Tabelle erzeugen

    ArrayList<Step> steps = process.getStep();
    for (int x = 0; x < steps.size(); x++) {
        HashMap<String, Object> row = new HashMap<String, Object>();
        Step actualStep = steps.get(x);

        // erste Spalte ist 'rank'
        // um die korrekte sortierung zu erhalten soll der rank-string auf jeweils 2 Stellen erweitert werden
        String[] rankArray = actualStep.getRank().split("\\.");
        Integer[] rankArrayInt = new Integer[rankArray.length];
        for (int y = 0; y < rankArray.length; y++) {
            rankArrayInt[y] = Integer.parseInt(rankArray[y]);
        }
        String rankFormated = String.format("%02d.%02d", rankArrayInt);
        row.put("stepRank", rankFormated);

        // zweite Spalte ist 'stepname'
        row.put("stepName", actualStep.getName());
        //            System.out.println("stepName: "+actualStep.getName());

        // dritte Spalte ist 'Beschreibung'
        row.put("stepDescription", actualStep.getDescription());
        //            System.out.println("stepRank: "+actualStep.getDescription());

        // wenn nicht der root-step, dann row eintragen
        if (!(actualStep.getName().equals(process.getRootstepname()))) {
            report.addField(row);
        }
    }

    try {
        report.fillReportFileToFile(jasperPathP40, jasperFilledPathP40);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pdf
    try {
        report.convertFileToPdf(jasperFilledPathP40, pdfPathP40);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // export to pptx
    try {
        report.convertFileToPptx(jasperFilledPathP40, pptxPathP40);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (JRException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    report = null;

    //////////////////////////////////////////

    // fuer jeden Step einen eigenen Input Report erzeugen

    for (Step actualStep : process.getStep()) {
        // root-step ueberspringen
        if (actualStep.getName().equals(process.getRootstepname())) {
            System.out.println("skipping step root");
        }

        // alle anderen auswerten
        else {

            report = new Reporter();

            // P51x) erstellen des p51
            System.out.println(
                    "info: generating p51 for step " + actualStep.getRank() + " => " + actualStep.getName());

            String stepRank = actualStep.getRank();

            String pdfPathP51 = null;
            String pptxPathP51 = null;
            String jasperPathP51 = null;
            String jasperFilledPathP51 = null;

            // P51x) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
            if (ini.get("pkraft-createdoc", "p51") != null) {
                pdfPathP51 = randomPathPdf + "/p5." + stepRank + ".1.pdf";
                pptxPathP51 = randomPathPptx + "/p5." + stepRank + ".1.pptx";
                jasperPathP51 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p51");
                jasperFilledPathP51 = randomPathJasperFilled + "/p5." + stepRank + ".1.jasperFilled";

                String[] rankArray = stepRank.split("\\.");
                Integer[] rankArrayInt = new Integer[rankArray.length];
                for (int x = 0; x < rankArray.length; x++) {
                    rankArrayInt[x] = Integer.parseInt(rankArray[x]);
                }
                String rankFormated = String.format("%03d.%03d", rankArrayInt);

                pdfRankFiles.put(rankFormated + ".1", pdfPathP51);
                pptxRankFiles.put(rankFormated + ".1", pptxPathP51);
            } else {
                System.err.println("no entry 'p51' found in ini file");
                System.exit(1);
            }

            report.setParameter("processName", process.getName());
            report.setParameter("processVersion", process.getVersion());
            report.setParameter("processArchitectCompany", process.getArchitectCompany());
            report.setParameter("processArchitectName", process.getArchitectName());
            report.setParameter("processArchitectMail", process.getArchitectMail());
            report.setParameter("processCustomerCompany", process.getCustomerCompany());
            report.setParameter("processCustomerName", process.getCustomerName());
            report.setParameter("processCustomerMail", process.getCustomerMail());

            report.setParameter("stepName", actualStep.getName());
            report.setParameter("stepRank", stepRank);
            report.setParameter("stepDescription", actualStep.getDescription());

            String aufruf = "";
            if (actualStep.getWork() != null) {
                // zusammensetzen des scriptaufrufs
                String interpreter = "";

                if (actualStep.getWork().getInterpreter() != null) {
                    interpreter = actualStep.getWork().getInterpreter();
                }

                aufruf = interpreter + " " + actualStep.getWork().getCommand();
                for (Callitem actualCallitem : actualStep.getWork().getCallitem()) {
                    aufruf += " " + actualCallitem.getPar();
                    if (!(actualCallitem.getDel() == null)) {
                        aufruf += actualCallitem.getDel();
                    }
                    if (!(actualCallitem.getVal() == null)) {
                        aufruf += actualCallitem.getVal();
                    }
                }
            } else if (actualStep.getSubprocess() != null) {
                aufruf = ini.get("apps", "pkraft-startinstance");
                aufruf += " --pdomain " + actualStep.getSubprocess().getDomain();
                aufruf += " --pname " + actualStep.getSubprocess().getName();
                aufruf += " --pversion " + actualStep.getSubprocess().getVersion();

                for (Commit actCommit : actualStep.getSubprocess().getStep().getCommit()) {
                    for (de.prozesskraft.pkraft.File actFile : actCommit.getFile()) {
                        aufruf += " --commitfile " + actFile.getGlob();
                    }
                    for (Variable actVariable : actCommit.getVariable()) {
                        aufruf += " --commitvariable " + actVariable.getKey() + "=" + actVariable.getValue();
                    }
                }
            }
            report.setParameter("stepWorkCall", aufruf);

            // P51x) bild an report melden
            report.setParameter("stepTopologyImagePath", stepTopologyImagePath.get(actualStep.getName()));

            // ueber alle lists iterieren
            for (List actualList : actualStep.getList()) {
                HashMap<String, Object> row = new HashMap<String, Object>();

                // Spalte 'Woher?'
                row.put("origin", "-");

                // Spalte 'typ'
                row.put("objectType", "wert");

                // Spalte 'minOccur'
                row.put("minOccur", "-");

                // Spalte 'maxOccur'
                row.put("maxOccur", "-");

                // Spalte 'Label'
                row.put("objectKey", actualList.getName());

                // Spalte 'Label'
                String listString = actualList.getItem().toString();
                row.put("objectDescription", listString.substring(1, listString.length() - 1));

                report.addField(row);
            }

            // ueber alle inits iterieren
            for (Init actualInit : actualStep.getInit()) {
                HashMap<String, Object> row = new HashMap<String, Object>();

                // Spalte 'Woher?'
                if (actualInit.getFromstep().equals(process.getRootstepname())) {
                    row.put("origin", "user/cb2");
                } else {
                    row.put("origin", actualInit.getFromstep());
                }

                // Spalte 'typ'
                row.put("objectType", actualInit.getFromobjecttype());

                // Spalte 'minOccur'
                row.put("minOccur", "" + actualInit.getMinoccur());

                // Spalte 'maxOccur'
                row.put("maxOccur", "" + actualInit.getMaxoccur());

                // Spalte 'Label'
                row.put("objectKey", actualInit.getListname());

                // Spalte 'Label'
                row.put("objectDescription", "-");

                report.addField(row);
            }

            try {
                report.fillReportFileToFile(jasperPathP51, jasperFilledPathP51);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // export to pdf
            try {
                report.convertFileToPdf(jasperFilledPathP51, pdfPathP51);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // export to pptx
            try {
                report.convertFileToPptx(jasperFilledPathP51, pptxPathP51);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            report = null;
        }
    }

    //////////////////////////////////////////

    // fuer jeden Step einen eigenen Output Report erzeugen

    for (Step actualStep : process.getStep()) {
        // root-step ueberspringen
        if (actualStep.getName().equals(process.getRootstepname())) {
            System.out.println("skipping step root");
        }

        // alle anderen auswerten
        else {

            report = new Reporter();

            // P52x) erstellen des p52
            System.out.println(
                    "info: generating p52 for step " + actualStep.getRank() + " => " + actualStep.getName());

            String stepRank = actualStep.getRank();

            String pdfPathP52 = null;
            String pptxPathP52 = null;
            String jasperPathP52 = null;
            String jasperFilledPathP52 = null;

            // P52x) feststellen, welches jasperreports-template fuer den angeforderten typ verwendet werden soll
            if (ini.get("pkraft-createdoc", "p52") != null) {
                pdfPathP52 = randomPathPdf + "/p5." + stepRank + ".2.pdf";
                pptxPathP52 = randomPathPptx + "/p5." + stepRank + ".2.pptx";
                jasperPathP52 = installDir.getAbsolutePath() + "/" + ini.get("pkraft-createdoc", "p52");
                jasperFilledPathP52 = randomPathJasperFilled + "/p5." + stepRank + ".1.jasperFilled";

                String[] rankArray = stepRank.split("\\.");
                Integer[] rankArrayInt = new Integer[rankArray.length];
                for (int x = 0; x < rankArray.length; x++) {
                    rankArrayInt[x] = Integer.parseInt(rankArray[x]);
                }
                String rankFormated = String.format("%03d.%03d", rankArrayInt);

                pdfRankFiles.put(rankFormated + ".2", pdfPathP52);
                pptxRankFiles.put(rankFormated + ".2", pptxPathP52);
            } else {
                System.err.println("no entry 'p52' found in ini file");
                System.exit(1);
            }

            report.setParameter("processName", process.getName());
            report.setParameter("processVersion", process.getVersion());
            report.setParameter("processArchitectCompany", process.getArchitectCompany());
            report.setParameter("processArchitectName", process.getArchitectName());
            report.setParameter("processArchitectMail", process.getArchitectMail());
            report.setParameter("processCustomerCompany", process.getCustomerCompany());
            report.setParameter("processCustomerName", process.getCustomerName());
            report.setParameter("processCustomerMail", process.getCustomerMail());

            report.setParameter("stepName", actualStep.getName());
            report.setParameter("stepRank", stepRank);

            // logfile ermitteln
            String logfile = "-";
            if (actualStep.getWork() != null) {
                if (actualStep.getWork().getLogfile() == null || actualStep.getWork().getLogfile().equals("")) {
                    report.setParameter("stepWorkLogfile", actualStep.getWork().getLogfile());
                }
            } else if (actualStep.getSubprocess() != null) {
                logfile = ".log";
            }
            report.setParameter("stepWorkLogfile", logfile);

            // zusammensetzen der return/exitcode informationen
            String exitInfo = "exit 0 = kein fehler aufgetreten";
            exitInfo += "\nexit >0 = ein fehler ist aufgetreten.";
            if (actualStep.getWork() != null) {
                for (Exit actualExit : actualStep.getWork().getExit()) {
                    exitInfo += "\nexit " + actualExit.getValue() + " = " + actualExit.getMsg();
                }
            }
            report.setParameter("stepWorkExit", exitInfo);

            // P52x) bild an report melden
            report.setParameter("stepTopologyImagePath", stepTopologyImagePath.get(actualStep.getName()));

            // ueber alle inits iterieren
            for (Commit actualCommit : actualStep.getCommit()) {

                // ueber alle files iterieren
                for (de.prozesskraft.pkraft.File actualFile : actualCommit.getFile()) {

                    HashMap<String, Object> row = new HashMap<String, Object>();

                    // Spalte 'destination'
                    if (actualCommit.isTorootPresent()) {
                        row.put("destination", "user/cb2");
                    } else {
                        row.put("destination", "prozessintern");
                    }

                    // Spalte 'objectType'
                    row.put("objectType", "file");

                    // Spalte 'minOccur'
                    row.put("minOccur", "" + actualFile.getMinoccur());

                    // Spalte 'maxOccur'
                    row.put("maxOccur", "" + actualFile.getMaxoccur());

                    // Spalte 'objectKey'
                    row.put("objectKey", actualFile.getKey());

                    // Spalte 'objectDescription'
                    row.put("objectDescription", actualFile.getDescription());

                    // Datensatz dem report hinzufuegen
                    report.addField(row);
                }

                // ueber alle variablen iterieren
                for (de.prozesskraft.pkraft.Variable actualVariable : actualCommit.getVariable()) {
                    HashMap<String, Object> row = new HashMap<String, Object>();

                    // Spalte 'destination'
                    if (actualCommit.isTorootPresent()) {
                        row.put("destination", "user/cb2");
                    } else {
                        row.put("destination", "prozessintern");
                    }

                    // Spalte 'objectType'
                    row.put("objectType", "variable");

                    // Spalte 'minOccur'
                    row.put("minOccur", "" + actualVariable.getMinoccur());

                    // Spalte 'maxOccur'
                    row.put("maxOccur", "" + actualVariable.getMaxoccur());

                    // Spalte 'objectKey'
                    row.put("objectKey", actualVariable.getKey());

                    // Spalte 'objectDescription'
                    row.put("objectDescription", actualVariable.getDescription());

                    // Datensatz dem report hinzufuegen
                    report.addField(row);
                }

            }
            try {
                report.fillReportFileToFile(jasperPathP52, jasperFilledPathP52);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // export to pdf
            try {
                report.convertFileToPdf(jasperFilledPathP52, pdfPathP52);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // export to pptx
            try {
                report.convertFileToPptx(jasperFilledPathP52, pptxPathP52);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (JRException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            report = null;
        }
    }

    // warten bis alles auf platte geschrieben ist
    try {
        Thread.sleep(1000);
    } catch (InterruptedException ex) {
        Thread.currentThread().interrupt();
    }

    // merge and output
    if (format.equals("pdf")) {
        mergePdf(pdfRankFiles, output);
    } else if (format.equals("pptx")) {
        mergePptx(pptxRankFiles, output);
    }

    System.out.println("info: generating process documentation ready.");
    System.exit(0);
}

From source file:com.clustercontrol.agent.job.RunHistoryUtil.java

/**
 * ??????/* w  w w  .  j  av  a 2 s  .  co m*/
 * FIXME
 * @return process
 */
protected static Process dummyProcess() {
    return new Process() {

        @Override
        public int waitFor() throws InterruptedException {
            return 0;
        }

        @Override
        public OutputStream getOutputStream() {
            return null;
        }

        @Override
        public InputStream getInputStream() {
            return null;
        }

        @Override
        public InputStream getErrorStream() {
            return null;
        }

        @Override
        public int exitValue() {
            return 0;
        }

        @Override
        public void destroy() {
        }
    };
}

From source file:com.bstek.dorado.console.performance.PerformanceMonitor.java

/**
 * // w  w  w.  j  a va  2s  .c o m
 * @param name
 * @param startTime
 * @param endTime
 * @param type
 */
public void monitoredProcess(String name, long startTime, long endTime, String type) {
    if (StringUtils.isNotEmpty(name)) {
        Process process = new Process();
        process.setName(name);
        process.setTime(startTime);
        process.setSpendTime(endTime - startTime);
        process.setType(type);
        process.setFreeMemory(Runtime.getRuntime().freeMemory());
        try {
            registerProcess(process);
        } catch (Exception e) {

        }
    }
}

From source file:de.prozesskraft.pkraft.PkraftPartUi1.java

/**
 * opens a process.pmb in a new tabItem/*from w  w w  . ja v  a2  s  . com*/
 * @param pathToInstance
 */
public void openInstance(String pathToInstance) throws IOException {
    boolean ctabMussNeuErzeugtWerden = true;

    // einlesen der instanz
    Process p1 = new Process();
    p1.setInfilebinary(pathToInstance);
    Process p2 = p1.readBinary();

    // gibt es den CTabItem bereits, soll dieser selektiert werden
    int counter = 2; // bereits 2 CTabItems vorhanden (pradar, pramp);

    // jeden eintrag der liste durchgehen und sehen ob das schon der gesuchte Map mit der id -> CTabItem ist
    for (Map<String, CTabItem> actIdCTabItem : processId_CTabItem) {
        for (String oneExistentId : actIdCTabItem.keySet()) {
            if (oneExistentId.equals(p2.getId())) {
                ctabMussNeuErzeugtWerden = false;
                tabFolder.setSelection(counter);
            }
        }
        counter++;
    }
    //         String pathToInstance2 = new java.io.File(pathToInstance).getCanonicalPath();
    //         
    //         // gibt es den CTabItem bereits, soll dieser selektiert werden
    //         int counter = 2; // bereits 2 CTabItems vorhanden (pradar, pramp);
    //         for(String oldPath : pmodel_id_item.keySet())
    //         {
    //            if(oldPath.equals(pathToInstance2))
    //            {
    //               System.err.println("instance already open: "+pathToInstance2);
    //               counter++;
    //               ctabMussNeuErzeugtWerden = false;
    //               tabFolder.setSelection(counter-1);
    //            }
    //            else
    //            {
    //               System.err.println("opening instance: " + pathToInstance2);
    //            }
    //         }

    // falls eine ansicht neu erzeugt werden muss
    if (ctabMussNeuErzeugtWerden) {
        // erstellen des items fuer pmodel
        CTabItem tabItemPmodel = new CTabItem(tabFolder, SWT.NONE);
        tabItemPmodel.setShowClose(true);

        Composite compositePmodel = new Composite(tabFolder, SWT.NONE);
        GridLayout gl_compositePmodel = new GridLayout(1, false);
        gl_compositePmodel.marginWidth = 0;
        gl_compositePmodel.marginHeight = 0;
        compositePmodel.setLayout(gl_compositePmodel);

        // falls es fehlschlaegt, kurz warten und nochmal versuchen
        PmodelPartUi1 pmodelUi = null;
        try {
            // Versuch 1
            pmodelUi = new PmodelPartUi1(compositePmodel, pathToInstance);
        } catch (NullPointerException e) {
            try {
                // kurz warten und nochmal versuchen
                Thread.sleep(200);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            // Versuch 2
            pmodelUi = new PmodelPartUi1(compositePmodel, pathToInstance);
        }

        //
        pmodelUi.setPkraft(this);
        tabItemPmodel.setText(pmodelUi.getProcess().getName() + " " + pmodelUi.getProcess().getId2() + " "
                + pmodelUi.getProcess().getId());
        tabItemPmodel.setToolTipText(pmodelUi.getProcess().getName() + " - "
                + pmodelUi.getProcess().getVersion() + " - " + pathToInstance);

        tabItemPmodel.addDisposeListener(entferne_ctabitem);

        // das neue tabItem dem tabFolder hinzufuegen
        tabItemPmodel.setControl(compositePmodel);

        // das neueste tabItem selektieren
        tabFolder.setSelection(tabFolder.getItemCount() - 1);

        // das neue tabItem dem map der bekannten tabItems hinzufuegen
        Map<String, CTabItem> newPmodel = new HashMap<String, CTabItem>();
        newPmodel.put(p2.getId(), tabItemPmodel);

        // der liste der bekannten CTabItems hinzufuegen
        this.processId_CTabItem.add(newPmodel);

        // das pmodel der liste der geoeffneten pmodels hinzufuegen
        this.CTabItem_pModel.put(tabItemPmodel, pmodelUi);
    }

}

From source file:net.spfbl.core.Analise.java

public static void initProcess() {
    int count = 0;
    while (count++ < 256 && getProcessTotal() > 0 && SEMAPHORE.tryAcquire()) {
        Process process = new Process();
        process.start();/*from   w  w w. j av a 2 s. c o m*/
    }
}

From source file:net.spfbl.core.Analise.java

private boolean addNew(String token) {
    if (!run) {/*  w w w .j  av  a2s . co m*/
        return false;
    } else if (!semaphoreSet.tryAcquire()) {
        return false;
    } else if (ipSet.contains(token)) {
        semaphoreSet.release();
        return false;
    } else if (processSet.contains(token)) {
        semaphoreSet.release();
        return false;
    } else if (resultSet.contains(token)) {
        semaphoreSet.release();
        return false;
    } else if (ipSet.add(token)) {
        semaphoreSet.release();
        if (SEMAPHORE.tryAcquire()) {
            Process process = new Process();
            process.start();
        }
        last = System.currentTimeMillis();
        return CHANGED = true;
    } else {
        return false;
    }
}

From source file:de.tbuchloh.kiskis.gui.common.Application.java

/**
 * start the application in a new Thread.
 *///from  w w  w .  ja  va2s. c o m
public void start() {
    final Thread runner = new Thread(new Process());
    runner.start();
}

From source file:tds.student.sql.repository.ConfigLoader.java

protected void loadForbiddenApps() throws ReturnStatusException {

    ForbiddenApps forbiddenApps = new ForbiddenApps();

    try (SQLConnection connection = getSQLConnection()) {

        //MultiDataResultSet resultSets = executeStatement (connection, CMD_GET_FORBIDDEN_APPS, parametersQuery, false);
        MultiDataResultSet resultSets = _studentDll.GetForbiddenApps_SP(connection,
                getTdsSettings().getClientName());

        Iterator<SingleDataResultSet> results = resultSets.getResultSets();
        // first expected result set
        if (results.hasNext()) {

            SingleDataResultSet firstResultSet = results.next();
            ReturnStatusException.getInstanceIfAvailable(firstResultSet);
            Iterator<DbResultRecord> firstRecords = firstResultSet.getRecords();
            while (firstRecords.hasNext()) {
                DbResultRecord record = firstRecords.next();
                forbiddenApps.addAgentOS(record.<String>get("AgentOS"), record.<String>get("OS_ID"));
            }/*from w w w . j  a  v a2 s. c  o m*/

            if (results.hasNext()) {
                SingleDataResultSet secondResultSet = results.next();
                Iterator<DbResultRecord> records = secondResultSet.getRecords();
                while (records.hasNext()) {
                    DbResultRecord record = records.next();
                    ForbiddenApps.Process process = forbiddenApps.new Process();
                    process.setOs(record.<String>get("OS_ID"));
                    process.setName(record.<String>get("ProcessName").toLowerCase());
                    process.setDescription(record.<String>get("ProcessDescription"));
                    forbiddenApps.addApplication(process.getOs(), process);
                }
            }
            if (results.hasNext()) {
                SingleDataResultSet thirdResultSet = results.next();
                Iterator<DbResultRecord> records = thirdResultSet.getRecords();
                while (records.hasNext()) {
                    DbResultRecord record = records.next();
                    ForbiddenApps.ExcludedSchool excludedSchool = forbiddenApps.new ExcludedSchool();
                    excludedSchool.setDistrictName(record.<String>get("DistrictName"));
                    excludedSchool.setDistrictID(record.<String>get("DistrictID"));
                    excludedSchool.setSchoolName(record.<String>get("SchoolName"));
                    excludedSchool.setSchoolID(record.<String>get("SchoolID"));
                    forbiddenApps.addExcludedSchool(excludedSchool);
                }
            }
        }

    } catch (SQLException e) {
        _logger.error(e.getMessage());
        throw new ReturnStatusException(e);
    }
    // Interlocked.Exchange(ref _forbiddenApps, forbiddenApps);
    synchronized (this) {
        _forbiddenApps = forbiddenApps;
    }
}

From source file:tds.student.sql.repositorysp.ConfigLoader.java

protected void loadForbiddenApps() throws ReturnStatusException {

    final String CMD_GET_FORBIDDEN_APPS = "BEGIN; SET NOCOUNT ON; exec GetForbiddenApps ${clientName}; end;";
    ForbiddenApps forbiddenApps = new ForbiddenApps();

    try (SQLConnection connection = getSQLConnection()) {

        SqlParametersMaps parametersQuery = new SqlParametersMaps();
        addClientParameter(parametersQuery);

        MultiDataResultSet resultSets = executeStatement(connection, CMD_GET_FORBIDDEN_APPS, parametersQuery,
                false);/*from   w ww . ja va  2  s . c o m*/

        Iterator<SingleDataResultSet> results = resultSets.getResultSets();
        // first expected result set
        if (results.hasNext()) {

            SingleDataResultSet firstResultSet = results.next();
            ReturnStatusException.getInstanceIfAvailable(firstResultSet);
            ReturnStatus returnStatus = ReturnStatus.parse(firstResultSet);

            System.out.println(firstResultSet);
            System.out.println(firstResultSet.getRecords());
            if (firstResultSet.getRecords().hasNext()) {
                DbResultRecord record = firstResultSet.getRecords().next();

                if (record != null) {
                    forbiddenApps.addAgentOS(record.<String>get("AgentOS"), record.<String>get("OS_ID"));
                }
                if (results.hasNext()) {
                    SingleDataResultSet secondResultSet = results.next();
                    Iterator<DbResultRecord> records = secondResultSet.getRecords();
                    while (records.hasNext()) {
                        record = records.next();
                        ForbiddenApps.Process process = forbiddenApps.new Process();
                        process.setOs(record.<String>get("OS_ID"));
                        process.setName(record.<String>get("ProcessName").toLowerCase());
                        process.setDescription(record.<String>get("ProcessDescription"));
                        forbiddenApps.addApplication(process.getOs(), process);
                    }
                }
                if (results.hasNext()) {
                    SingleDataResultSet thirdResultSet = results.next();
                    Iterator<DbResultRecord> records = thirdResultSet.getRecords();
                    while (records.hasNext()) {
                        record = records.next();
                        ForbiddenApps.ExcludedSchool excludedSchool = forbiddenApps.new ExcludedSchool();
                        excludedSchool.setDistrictName(record.<String>get("DistrictName"));
                        excludedSchool.setDistrictID(record.<String>get("DistrictID"));
                        excludedSchool.setSchoolName(record.<String>get("SchoolName"));
                        excludedSchool.setSchoolID(record.<String>get("SchoolID"));
                        forbiddenApps.addExcludedSchool(excludedSchool);
                    }
                }
            }
        }

    } catch (SQLException e) {
        _logger.error(e.getMessage());
        throw new ReturnStatusException(e);
    }
    // Interlocked.Exchange(ref _forbiddenApps, forbiddenApps);
    synchronized (this) {
        _forbiddenApps = forbiddenApps;
    }
}

From source file:de.prozesskraft.pkraft.Manager.java

/**
 * es soll so lange der process weitergetrieben werden, bis es keine veraenderung in den stati mehr gibt
 *//*from w  ww .  ja  v  a  2  s  . c  o m*/
private static void pushProcessAsFarAsPossible(String pathBinary, boolean onlyPush) {
    // zeitmarker setzen fuer timerThread
    lastRun = System.currentTimeMillis();

    // prozess instanz frisch einlesen
    System.err.println("debug: rereading instance");
    Process p1 = new Process();
    p1.setInfilebinary(pathBinary);
    p1.setOutfilebinary(pathBinary);
    Process process = p1.readBinary();
    System.err.println("debug: rereading instance done");
    process.log("debug", "rereading instance done");

    // falls managerIds nicht zusammenpassen, soll beendet werden
    // und dem alternativen thread mit flag signalisieren, dass es vorbei ist
    if (!managerid.equals(process.getManagerid())) {
        System.err.println("i'm manager " + managerid + " - another instance of pkraft-manager took over "
                + process.getManagerid() + ". killing myself.");
        exit = true;
        System.exit(0);
    }

    // beenden, falls process.run == false ist
    if (!process.run) {
        System.err.println("info: process manager exits, because process.run is false");
        exit = true;
        System.exit(0);
    }

    // 1) timeSerie loadAverage
    double actLoadAverage = ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage();
    process.getTimeSerieLoadAverage().addValue(String.valueOf(actLoadAverage));

    if ((process.getStepStartLoadAverageBelow() != null)
            && (actLoadAverage > process.getStepStartLoadAverageBelow())) {
        // warte-faktor erhoehen
        factorSleepBecauseOfLoadAverage += 0.5;
    } else {
        // warte faktor resetten
        factorSleepBecauseOfLoadAverage = 1.0f;
    }

    // 2) die groesse des binary-files festhalten
    long fileSizeInKB = fileBinary.length() / 1024;

    System.err.println("debug: file size is now " + String.valueOf(fileSizeInKB) + " kB");
    process.getTimeSerieBinarySize().addValue(String.valueOf(fileSizeInKB));
    //p3.fileBinary.length() / 1024;

    // DEBUGGING
    // 3) die groesse der einzelnen steps festhalten
    String dieGroessenAlsString = "";
    for (Step actStep : process.getStep()) {
        dieGroessenAlsString += "   " + actStep.getName() + "=" + ObjectGraphMeasurer.measure(actStep);
    }
    process.getTimeSerieStepSize().addValue(dieGroessenAlsString);
    // DEBUGGING

    process.log("debug", "manager " + managerid + ": actual infilexml is: " + process.getInfilexml());
    process.log("debug", "manager " + managerid + ": reading binary file: " + process.getInfilebinary());
    // die manager-id mit eigener vergleichen. wenn nicht gleich, dann beenden.
    if (!(process.getManagerid() == managerid)) {
        //               p3.log("warn", "manager "+managerid+": it appears that another manager (id: "+p3.getManagerid()+") took over. killing myself. bye.");
        System.err.println("it appears another instance of manager (id: " + process.getManagerid()
                + ") took over. so i'm (id: " + managerid + ") not longer needed. killing myself. byebye.");
        exit = true;
        System.exit(0);
    }

    boolean imProzessHatSichWasGeaendert = true;
    System.err.println(
            "debug: variable imProzessHatSichWasGeaendert manuell gesetzt auf " + imProzessHatSichWasGeaendert);
    process.log("debug",
            "variable imProzessHatSichWasGeaendert manuell gesetzt auf " + imProzessHatSichWasGeaendert);

    while (process.run && imProzessHatSichWasGeaendert) {
        System.err.println("debug: deshalb wird die while schleife erst mal durchlaufen");
        process.log("debug", "deshalb wird die while schleife erst mal durchlaufen");

        // prozess laufen lassen
        process.doIt(ini.get("apps", "pkraft-syscall"), ini.get("apps", "pkraft-manager"),
                ini.get("process", "domain-installation-directory"));

        // setzen der schlafdauer sleepMinutes. richtet sich nach dem feld stepStartDelayMinutes falls dieses existiert
        if (process.stepStartDelayMinutesMinimumOfInitializedSteps() != null) {
            loopMinutes = process.stepStartDelayMinutesMinimumOfInitializedSteps();
            if (loopMinutes < 1) {
                loopMinutes = 1;
            }
        } else {
            loopMinutes = 5;
        }

        // hat sich was geaendert?
        imProzessHatSichWasGeaendert = process.isStepStatusChangedWhileLastDoIt();
        System.err.println("debug: did some step changed its status? " + imProzessHatSichWasGeaendert);
        process.log("debug", "did some step changed its status? " + imProzessHatSichWasGeaendert);

        // finished
        if (process.getStatus().equals("finished")) {
            System.err.println("debug: status is finished");

            // wenn der prozess den status 'finished' hat, soll dieses programm beendet werden
            process.run = false;
            process.log("info", "manager " + managerid
                    + ": process instance is finished. goodbye from manager id " + process.getManagerid());
            process.setTimeOfProcessFinishedOrError(System.currentTimeMillis());
        }

        // error
        else if (process.getStatus().equals("error")) {
            System.err.println("debug: status is error");
            process.run = false;
            process.log("info", "error in process detected. setting run = false");
            process.log("info", "stopping manager " + process.getManagerid());
            process.setTimeOfProcessFinishedOrError(System.currentTimeMillis());

            // errorcode string erzeugen
            String exitCode = "error-in-steps:";
            for (Step actStep : process.getStepError()) {
                exitCode = exitCode + "," + actStep.getName();
            }
        }
    }

    // binary und statistik files updaten
    updateFile(process);

    // pradar updaten
    pradarAttend(process.getInfilebinary());

    if (!process.run) {
        exit = true;
        System.exit(0);
    }

    // da prozess nicht mehr weiterging, werden watchKeys auf laufende steps erstellt
    if (!onlyPush) {
        process.log("info", "creating WatchKeys on every working step");
        System.err.println("info: creating WatchKeys on every working step");
        try {
            createWatchKeysForAllRunningSteps(process);
        }
        // falls das scheitert, soll einfach 1 minute gewartet werden
        catch (IOException e) {
            // TODO Auto-generated catch block
            System.err.println("error: failed to register file watchers. sleeping 1 minute instead");
            e.printStackTrace();
        }
    }
}