Changeset 2407

Timestamp:

Feb 28, 2010 7:39:48 AM (11 years ago)

Author:

wehart

Message:

Revisions to get the GUI working with
subprocess execution.

File:

• coopr.gui.pyomo/trunk/coopr/gui/pyomo/GUI.py (modified) (9 diffs)

coopr.gui.pyomo/trunk/coopr/gui/pyomo/GUI.py

@@ +1 @@
+
+import time
+import sys
 from pawt import swing
 from java.awt import GridBagLayout, GridBagConstraints, FlowLayout
@@ -9 +12 @@
 import coopr.pyomo.scripting
 from threading import Thread
+import pyutilib.misc
+import pyutilib.subprocess
+import StringIO
+from javax.swing import SwingWorker, SwingUtilities
+from java.util.concurrent import CancellationException
+from java.util.concurrent import ExecutionException
+from java.lang import Runtime, Runnable, ProcessBuilder
+from java.io import InputStreamReader, BufferedReader
+from java.awt import Font
+
 
 
@@ -81 +94 @@
 
 
-class RunPyomo(Thread):
-
-    def __init__(self, options, args, parser):
-        self.options=options
-        self.args=args
-        self.parser=parser
-
-    def run(self):
-        self.ostream = StringIO.StringIO()
-        pyutilib.misc.redirect(self.ostream)
-        coopr.pyomo.scripting.pyomo.run_pyomo(options, args, parser)
-        pyutilib.misc.reset_redirect()
+class PyomoWorker(SwingWorker):
+    "Class implementing long running task as a SwingWorker thread"
+
+    def __init__(self, options, args, parser, gui, shell=True):
+        SwingWorker.__init__(self)
+        self.options=options
+        self.args=args
+        self.parser=parser
+        self.shell=shell
+        self.gui=gui
+        self.cmd=[]
+        self.stdout_reader_done = False
+        self.stderr_reader_done = False
+
+    def doInBackground(self):
+        pyomocmd = os.path.dirname(sys.executable)+os.sep+"pyomo"
+        self.cmd = [sys.executable, pyomocmd]
+        for opt in self.parser.option_list:
+            if len(opt._long_opts) > 0:
+                key = opt._long_opts[0][2:]
+            else:
+                key = opt._short_opts[0][1:]
+            if self.options[key] is None:
+                continue
+            if self.options[key] == opt.default:
+                continue
+            if type(self.options[key]) is list:
+                for item in self.options[key]:
+                    self.cmd.append("--"+key)
+                    self.cmd.append(str(item))
+            else:
+                self.cmd.append("--"+key)
+                self.cmd.append(str(self.options[key]))
+        for arg in self.args[1:]:
+            if arg != '':
+                self.cmd.append(arg)
+        self.update("Executing the following command:\n\n  "+' '.join(self.cmd)+"\n", self.gui)
+
+        def stdout_reader(stream, self):
+            s = ''
+            while (s != None):
+                if self.isCancelled():
+                    self.stdout_reader_done=True
+                    return
+                s = stream.readLine()
+                if s is None:
+                    self.stdout_reader_done=True
+                    return
+                else:
+                    self.update(s+"\n", self.gui)
+            self.stdout_reader_done=True
+
+        def stderr_reader(stream, buffer, self):
+            s = ''
+            while (s != None):
+                if self.isCancelled():
+                    self.stderr_reader_done=True
+                    return
+                s = stream.readLine()
+                if s is None:
+                    self.stderr_reader_done=True
+                    return
+                else:
+                    buffer += s
+            self.stderr_reader_done=True
+
+        self.cmd = ['cmd.exe', '/C', 'call'] + self.cmd
+
+        builder = ProcessBuilder(self.cmd)
+        proc = builder.start()
+        stdInput = BufferedReader(InputStreamReader(proc.getInputStream()))
+        stdError = BufferedReader(InputStreamReader(proc.getErrorStream()))
+        #
+        try:
+            self.update("\n--- PYOMO START STDOUT ---\n\n", self.gui)
+            self.buffer=''
+            self.outt = Thread(target=stdout_reader, args=(stdInput,self))
+            self.outt.daemon = True
+            self.outt.start()
+            self.errt = Thread(target=stderr_reader, args=(stdError,self.buffer,self))
+            self.errt.daemon = True
+            self.errt.start()
+            ##print "HERE 2"
+            self.outt.join()
+            ##print "HERE 3"
+            self.errt.join()
+            ##print "HERE 4"
+            self.outt = None
+            self.errt = None
+        except Exception, e:
+            raise e
+            ##print "HERE 5",str(e)
+        finally:
+            ##print "HERE 6"
+            self.final_output()
+            self.finish(self.gui)
+    
+    def final_output(self):
+        #while not self.stdout_reader_done or not self.stderr_reader_done:
+            #print "HERE Y"
+            #time.sleep(0.1)
+        print "HERE X"
+        if self.isCancelled():
+            self.update("--- Pyomo Solver Terminated Early!  ----\n", self.gui)
+        self.update("\n--- PYOMO END STDOUT ---\n", self.gui)
+        #
+        if len(self.buffer) > 0:
+            self.update("\n\n--- PYOMO START STDERR ---\n\n", self.gui)
+            self.update(self.buffer, self.gui)
+            self.update("\n--- PYOMO END STDERR ---\n", self.gui)
+
+    def finish(self, gui):
+        class updater( java.lang.Runnable ) :
+            def run( self ) :
+                gui._setButtonStates(started=False, finished=True)
+        if SwingUtilities.isEventDispatchThread() :
+            updater().run()
+        else :
+            SwingUtilities.invokeLater( updater() )
+
+    def update(self, text, gui):
+        #print "X",text
+        tab = gui.tab_info[gui.tabbed.getSelectedIndex()]
+        # now update the GUI,  create an java.lang.Runnable that
+        # does the work
+        class updater( java.lang.Runnable ) :
+            def run( self ) :
+                tab.output.append(text)
+        #
+        if SwingUtilities.isEventDispatchThread() :
+            # we are already in the AWT_EventQueue thread, it is
+            # safe to touch the GUI
+            updater().run()
+        else :
+            # request that the updater be run in the
+            # AWT_EventQueue thread
+            SwingUtilities.invokeLater( updater() )
+        ###print "UPDATE - done"
+
+    def process(self, text):
+        self.gui.output.append(text)
+
+    def done(self):
+        try:
+            self.get()
+        except CancellationException, e:
+            # ignore exception caused when worker is explicitly canceled
+            pass
+        except ExecutionException, e:
+            raise SystemExit, e.getCause()
+
 
 
@@ -119 +271 @@
         # Finish up and set the size
         self.frame.pack()
-        self.frame.visible = 1
+        # ACTIVATE AND THEN SET VISIBLE
+        self.frame.setVisible(1)
         self.frame.size = self.frame.getPreferredSize()
 
@@ -151 +304 @@
         bag.addRow(tab.text2)
         #
-        # Creating a text area for the command that will be executed
-        #
-        ##tab.input = swing.JTextArea("", 6, 80)
-        ##bag.addRow(tab.input)
-        ##tab.input.append("COMMAND %d" % self.tab_id)
-
-        #
         # create panel for the options in the command line
         #
         options_panel = swing.JPanel(FlowLayout(alignment=FlowLayout.LEFT))
-        tab.parser = coopr.pyomo.scripting.pyomo.create_parser()
-        tab.parse_options = tab.parser.parse_args(args=['pyomo'])[0]
+        tab.parser = coopr.pyomo.scripting.pyomo.create_parser()
+        tab.parse_options = tab.parser.parse_args(args=['pyomo'])[0]
         tab.options_pane, tab.options_table = self.create_options_table(tab.parser, tab.parse_options)
         options_panel.add(tab.options_pane)
@@ -172 +318 @@
         tab.buttonExecute = swing.JButton("Execute", actionPerformed=self._buttonExecute)
         buttons.add(tab.buttonExecute)
+        tab.buttonStop = swing.JButton("Stop", actionPerformed=self._buttonStop)
+        buttons.add(tab.buttonStop)
         tab.buttonClearOutput = swing.JButton("Clear Output", actionPerformed=self._buttonClearOutput)
         buttons.add(tab.buttonClearOutput)
         bag.addRow(buttons)
-        #
-        tab.output = swing.JTextArea("",6,80)
+        self._setButtonStates(started=False, finished=True)
+        #
+        tab.output = swing.JTextArea("",15,80)
+        tab.output.setFont( Font('Courier New', Font.PLAIN, 12) )
+        #tab.output.setFont( Font('Lucida Console', Font.PLAIN, 12) )
         pane = swing.JScrollPane(tab.output,\
-                    verticalScrollBarPolicy=swing.JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
-                    size=(1000,10000))
+                    verticalScrollBarPolicy=swing.JScrollPane.VERTICAL_SCROLLBAR_ALWAYS)
+                    #size=(1000,10000))
         bag.addRow(pane, weighty=1.0)
-        tab.output.append("DRAFT GUI for PYOMO COMMAND DRIVER\n\n")
+        #tab.output.append("DRAFT GUI for PYOMO COMMAND DRIVER\n\n")
 
     def create_options_table(self, parser, parse_options):
@@ -187 +338 @@
         options_table.initialize(parser, parse_options)
         scrollPane = swing.JScrollPane()
-        scrollPane.setPreferredSize(java.awt.Dimension(600,200))
+        scrollPane.setPreferredSize(java.awt.Dimension(600,100))
+        scrollPane.setMinimumSize(java.awt.Dimension(300,100))
         scrollPane.getViewport().setView(options_table)
         return scrollPane, options_table
@@ -223 +375 @@
         return menubar
 
+    def _setButtonStates(self, started, finished):
+        tab = self.tab_info[self.tabbed.getSelectedIndex()]
+        tab.buttonExecute.enabled = not started
+        tab.buttonStop.enabled = started
+        tab.buttonClearOutput.enabled = finished
+
     def _fileNewCommand(self, event=None):
         self.create_tab()
@@ -279 +437 @@
 
     def _buttonExecute(self, event=None):
-        if not self.tab_info[self.tabbed.getSelectedIndex()].thread is None:
-            return
-        tab = self.tab_info[self.tabbed.getSelectedIndex()]
-        options = tab.options_table.get_options()
-        #
-        thread = RunPyomo(options, ['pyomo', tab.text1.text, tab.text2.text], tab.parser)
-        tab.thread = thread
-        thread.start()
+        self._setButtonStates(started=True, finished=False)
+        tab = self.tab_info[self.tabbed.getSelectedIndex()]
+        tab.output.text = ""
+        options = tab.options_table.get_options()
+        tab.PyomoWorker = PyomoWorker(options, ['pyomo', tab.text1.text, tab.text2.text], tab.parser, self)
+        tab.PyomoWorker.execute()
+
+    def _buttonStop(self, event=None):
+        #self._setButtonStates(started=False, finished=True)
+        tab = self.tab_info[self.tabbed.getSelectedIndex()]
+        tab.PyomoWorker.cancel(True)
+        #tab.PyomoWorker = None
 
     def _buttonClearOutput(self, event=None):