staxmonitorsubjobextension.java

Software Testing Automation Framework (STAF)的开发代码

            rowData[4] = startDate + "-" + startTime;
            rowData[5] = "00:00:00";
            rowData[6] = "";

            fSubjobTableModel.addRow(rowData);

            STAXMonitorUtil.updateRowHeights(fSubjobTable, 6);
            STAXMonitorUtil.sizeColumnsToFitText(fSubjobTable);

            Vector subjobDataVector = new Vector();

            addRow(subjobDataVector, "Job ID", jobID);
            addRow(subjobDataVector, "Job Name", jobName);
            addRow(subjobDataVector, "Clear Logs", clearLogs);
            addRow(subjobDataVector, "Log TC Elapsed Time", logTCElapsedTime);
            addRow(subjobDataVector, "Log TC Num Starts", logTCNumStarts);
            addRow(subjobDataVector, "Log TC Start/Stop", logTCStartStop);
            addRow(subjobDataVector, "Job File", jobFile);

            if (!jobFileMachine.equals(""))
            {
                addRow(subjobDataVector, "Job File Machine", jobFileMachine);
            }

            addRow(subjobDataVector, "Function", function);
            addRow(subjobDataVector, "Function Args", functionArgs);

            boolean endOfScripts = false;
            int scriptIndex = 0;

            while (!endOfScripts)
            {
                String scriptfile = (String)map.get("scriptfile" +
                                                    scriptIndex++);

                if (scriptfile != null)
                {
                    if (scriptIndex == 1 && !scriptFilesMachine.equals(""))
                    {
                        addRow(subjobDataVector, "Script Files Machine",
                               scriptFilesMachine);
                    }

                    addRow(subjobDataVector, "Script File #" + scriptIndex,
                           scriptfile);
                }
                else
                {
                   endOfScripts = true;
                }
            }

            endOfScripts = false;
            scriptIndex = 0;

            while (!endOfScripts)
            {
                String script = (String)map.get("script" + scriptIndex++);

                if (script != null)
                {
                    addRow(subjobDataVector, "Script #" + scriptIndex, script);
                }
                else
                {
                   endOfScripts = true;
                }
            }

            addRow(subjobDataVector, "Started", startDate + "-" + startTime);
            addRow(subjobDataVector, "Block", block);

            synchronized(fSubjobHashtable)
            {
                fSubjobHashtable.put("Job " + jobID + " - " + jobName,
                    subjobDataVector);
            }

            fSubjobStartTimes.put(jobID,
                STAXMonitorUtil.getCalendar2(startDate, startTime));
        }
        else if (status.equals("stop"))
        {
            String result = STAFMarshallingContext.formatObject(
              map.get("result"));
            
            Vector jobsVector = fSubjobTableModel.getDataVector();

            boolean found = false;
            int rowIndex = -1;

            for (int j = 0; j < jobsVector.size(); j++)
            {
                if (!found)
                {
                    if (((Vector)(jobsVector.elementAt(j))).
                               elementAt(0).equals(jobID))
                    {
                        found = true;
                        rowIndex = j;
                    }
                }
            }

            if (rowIndex > -1)
            {
                fSubjobTableModel.setValueAt("Complete", rowIndex, 3);
                fSubjobTableModel.setValueAt(result, rowIndex, 6);
            }

            fSubjobStartTimes.remove(jobID);

            synchronized (fSubjobTable)
            {
                fSubjobTable.updateUI();
                STAXMonitorUtil.updateRowHeights(fSubjobTable, 6);
                STAXMonitorUtil.sizeColumnsToFitText(fSubjobTable);
            }
        }
    }

    public void addRow(Vector vector, String name, String value)
    {
        Vector newRow = new Vector(2);
        newRow.add(name);
        newRow.add(value);
        vector.add(newRow);
    }

    public void actionPerformed(ActionEvent e)
    {
        if (e.getSource() == fSubjobStartMonitorMenuItem)
        {
            fSubjobPopupMenu.setVisible(false);

            synchronized(fSubjobModelSorter)
            {
                int rowIndex = fSubjobTable.getSelectedRow();
                String jobNumber = (String)fSubjobTable.getValueAt(rowIndex, 0);

                fMonitorFrame.getParentMonitor().
                    monitorExistingJob(jobNumber, -1);
            }
        }
        else if (e.getSource() == fSubjobShowJobLogMenuItem)
        {
            fSubjobPopupMenu.setVisible(false);

            synchronized(fSubjobModelSorter)
            {
                int rowIndex = fSubjobTable.getSelectedRow();
                String jobNumber =
                    (String)fSubjobTable.getValueAt(rowIndex, 0);

                String[] showLogParms = new String[6];
                showLogParms[0] = "-machine";
                showLogParms[1] = fStaxMachine;
                showLogParms[2] = "-machineNickname";
                showLogParms[3] = fStaxMachineNickname;
                showLogParms[4] = "-name";
                showLogParms[5] = fStaxServiceName.toUpperCase() +
                    "_Job_" + jobNumber;

                STAXMonitorLogViewer logViewer =
                    new STAXMonitorLogViewer(this, fHandle, showLogParms);
            }
        }
        else if (e.getSource() == fSubjobShowJobUserLogMenuItem)
        {
            fSubjobPopupMenu.setVisible(false);

            synchronized(fSubjobModelSorter)
            {
                int rowIndex = fSubjobTable.getSelectedRow();
                String jobNumber =
                    (String)fSubjobTable.getValueAt(rowIndex, 0);

                String[] showLogParms = new String[6];
                showLogParms[0] = "-machine";
                showLogParms[1] = fStaxMachine;
                showLogParms[2] = "-machineNickname";
                showLogParms[3] = fStaxMachineNickname;
                showLogParms[4] = "-name";
                showLogParms[5] = fStaxServiceName + "_Job_".toUpperCase() +
                    jobNumber  + "_User";

                STAXMonitorLogViewer logViewer =
                    new STAXMonitorLogViewer(this, fHandle, showLogParms);
            }
        }
        else if (e.getSource() == fSubjobTerminateMenuItem)
        {
            fSubjobPopupMenu.setVisible(false);

            synchronized(fSubjobModelSorter)
            {
                int rowIndex = fSubjobTable.getSelectedRow();
                String jobNumber =
                    (String)fSubjobTable.getValueAt(rowIndex, 0);

                int confirmation = JOptionPane.showConfirmDialog(this,
                         "Are you certain that you want\n" +
                         "to terminate Job # " + jobNumber + " ?",
                         "Confirm Job Termination",
                         JOptionPane.YES_NO_OPTION,
                         JOptionPane.QUESTION_MESSAGE);

                if (!(confirmation == JOptionPane.YES_OPTION))
                {
                    return;
                }

                String request = "TERMINATE JOB " + jobNumber;

                STAFResult result = fHandle.submit2(
                    fStaxMachine, fStaxServiceName, request);

                if (result.rc != 0)
                {
                    fMonitorFrame.getParentMonitor().
                        showErrorDialog(this, "An error was encountered while "
                        + "attempting to terminate jobID "
                        + jobNumber + " rc=" + result.rc
                        + " result=" + result.result);
                }
            }
        }
    }

    public void mouseClicked(MouseEvent e)
    {
        String subjobID = (String)
            fSubjobTable.getValueAt(fSubjobTable.getSelectedRow(), 0);

        String subjobName = (String)
            fSubjobTable.getValueAt(fSubjobTable.getSelectedRow(), 1);

        synchronized(fSubjobHashtable)
        {
            fMonitorFrame.updateCurrentSelection("Job " + subjobID +
                " - " + subjobName, (Vector)fSubjobHashtable.get("Job " +
                subjobID + " - " + subjobName));
        }
    }

    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}

    public void mousePressed(MouseEvent e)
    {
        displayPopup(e);
    }

    public void mouseReleased(MouseEvent e)
    {
        displayPopup(e);
    }

    public void displayPopup(MouseEvent e)
    {
        if (e.isPopupTrigger())
        {
            synchronized (fSubjobModelSorter)
            {
                int tableIndex =
                    fSubjobTable.rowAtPoint(new Point(e.getX(), e.getY()));

                if (tableIndex > -1)
                {
                    fSubjobTable.setRowSelectionInterval(tableIndex,
                                                         tableIndex);

                    String status =
                        (String)fSubjobTableModel.getValueAt(tableIndex, 3);

                    if (status.equals("Complete"))
                    {
                        fSubjobTerminateMenuItem.setEnabled(false);
                    }
                    else
                    {
                        fSubjobTerminateMenuItem.setEnabled(true);
                    }

                    fSubjobPopupMenu.show(e.getComponent(), e.getX(), e.getY());
                }
            }
        }
    }

    public void term()
    {
        boolean fContinueSubjobMonitor = false;

        STAXMonitorUtil.freeHandle(fHandle.getHandle());
    }

    class MonitorElapsedTime extends Thread
    {
        public void run()
        {
            final int waitTime = fMonitorFrame.getElapsedTimeInterval();

            if (waitTime == 0)
                return;

            while (fContinueElapsedTime)
            {
                synchronized(fSubjobTableModel)
                {
                    Runnable SubjobRunnable = new Runnable()
                    {
                        public void run()
                        {
                            Vector dataVector =
                                fSubjobTableModel.getDataVector();

                            for (int i = 0; i < dataVector.size(); i++)
                            {
                                Vector currentRow =
                                    (Vector)(dataVector.elementAt(i));

                                String jobID =
                                    (String)currentRow.elementAt(0);

                                final int row = i;

                                synchronized(fSubjobStartTimes)
                                {
                                    Calendar SubjobStarted = (Calendar)
                                        fSubjobStartTimes.get(
                                        jobID);

                                    if (SubjobStarted != null)
                                    {
                                        fSubjobTableModel.setValueAt(
                                            STAXMonitorUtil.getElapsedTime(
                                            SubjobStarted), row, 5);
                                    }
                                }
                            }

                            fSubjobTable.repaint();
                        }
                    };

                    try
                    {
                        SwingUtilities.invokeAndWait(SubjobRunnable);
                    }
                    catch (InterruptedException ex)
                    {
                         ex.printStackTrace();
                    }
                    catch (InvocationTargetException ex)
                    {
                         ex.printStackTrace();
                    }
                }

                try
                {
                    Thread.sleep(waitTime);
                }
                catch (InterruptedException ex)
                {
                }
            }
        }
    }

}