FileToolImpl.py

Go to the documentation of this file.

#!/usr/bin/env python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__abstract__ = "ScriptEngine Global Panel Implementation"
__date__     = "2002/10/11 00:00:00"
__updated__  = "$Date: 2006/03/23 02:12:23 $"
__version__  = "$Revision: 1.1 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import sys, os
from qt import *
import logging as log

from LICOS.scriptEngine.FileTool import FileTool

from LICOS.lib.LATconstants import *
from LICOS.lib.cmdTlmDb.FILE import FswFile, FswFileFromDisk, FswFileFromData, FswFileID

class FileToolImpl(FileTool):
  """!\brief Real time file upload and download GUI.

     This tool provides the capability of uploading and downloading
     files to and from the LAT instrument through the VSC interface.
     
     It uses the high level FILE methods to construct a series of
     telecommands to start the upload/download.

     It is a current feature that this tool will not upload a
     file to either of the EEPROMS.
  """
  def __init__(self, common,
               parent = None, name = None, modal = False, fl = 0):
    """!\brief FileToolImpl Constructor

    \param common A ScriptEngineCommon instance
    
    \param parent The parent GUI (typically the Run Control GUI)
    \param name   Name of the GUI
    \param modal  Whether the GUI is Modal (blocking)
    \param fl     Qt flags
     """
    FileTool.__init__(self, parent, name, modal, fl)

    # Three buttons, three connections...
    self.connect(self.ApplyButton, SIGNAL("clicked()"), self.apply)
    self.connect(self.ClearButton, SIGNAL("clicked()"), self.clear)
    self.connect(self.ExecuteButton, SIGNAL("clicked()"), self.execute)

    # cache the ids of some of the radio buttons.  We'll use them later
    self.__downloadBtnID = self.TransferSelector.id(self.DownloadRadioBtn)
    self.__uploadBtnID   = self.TransferSelector.id(self.UploadRadioBtn)

    self.TransferSelector.setButton(self.__downloadBtnID)

    if common is None:
      print "no Common, setting to None"
    else:
      pass

    self.__common = common

  def lcat(self):
    """ Return the LCATcmdDb instance of self.__common
    """
    if self.__common is not None:
      return self.__common.getLCATcmd()

  def apply(self):
    """ Apply the settings to the text edits
    """
    unit = self.UnitSelector.currentText()
    
    onboardTextRep = "%s:%s" % (unit, str(self.__fid()))

    # upload or download?
    if self.TransferSelector.selectedId() == self.__uploadBtnID:
      self.DestinationEdit.setText( onboardTextRep )
    else:
      self.OriginEdit.setText( onboardTextRep )

  def clear(self):
    """ Clear the form and reset to default values
    """
    self.UnitSelector.setCurrentItem(0)     # SIU
    self.DeviceSelector.setCurrentItem(1)   # RAM
    self.FileNoSelector.setValue(0)         # file 0
    self.DirSelector.setValue(0)            # directory 0
    self.OriginEdit.clear()
    self.DestinationEdit.clear()

  def execute(self):
    """ Execute upload or download command
        Also perform consistency checks
    """
    
    if self.TransferSelector.selectedId() == self.__uploadBtnID:
      if self.uploadConsistent():
        self.upload()
    else:
      if self.downloadConsistent():
        self.download()


  def upload(self):
    """ Upload the file pointed to by the current GUI state.

    """
    fName = str(self.OriginEdit.text())

    fswFile = FswFileFromDisk( self.__fid(), fName )

    if self.lcat() is not None:
      # Gotta enable command confirmation
      cmdConf = self.lcat().isCmdConfirmTelemEnabled()
      if not cmdConf:
        self.lcat().enableCmdConfirmTelem()
        
      status = self.lcat().FILE.uploadFile( fswFile, FSW_UNIT_NAMES.index(self.UnitSelector.currentText()) )

      if not cmdConf: # put cmdConf back
        self.lcat().disableCmdConfirmTelem()

    else:
      self.errorBox("LCAT object is None.  Not uploading")
      return

    if not status:
      self.errorBox("Upload failed")


  def download(self):
    """ Download the file pointed to by the current GUI state to disk

        Several consistency checks are done:
        a) If there is nothing in the destination box, mit an errorbox and return
    """
    fName = str(self.DestinationEdit.text())
    
    print fName, os.path.exists(fName)

    if self.lcat() is not None:
      # Gotta enable command confirmation
      cmdConf = self.lcat().isCmdConfirmTelemEnabled()
      if not cmdConf:
        self.lcat().enableCmdConfirmTelem()
        
      fswFile = self.lcat().FILE.downloadFile( FSW_UNIT_NAMES.index(self.UnitSelector.currentText()),
                                               self.__fid() )
      if not cmdConf:
        self.lcat().disableCmdConfirmTelem()
    else:
      self.errorBox("LCAT object is None.  Not uploading")
      return

    outFile = file(fName, 'w+')
    outFile.write( fswFile.binary() )
    outFile.close()

  def uploadConsistent(self):
    """
        Several consistency checks are done for uploads:
        a) If destination != RAM, emit an errorbox and return
        b) If there is nothing in the origin box, emit an errorbox and return
        c) If the origin file doesn't exist, emit an errorbox and return.

    """
    # Refuse to upload when device != RAM
    if self.DeviceSelector.currentText() != 'RAM':
      self.errorBox("Uploads through this interface are only allowed to go to RAM")
      #self.DeviceSelector.setCurrentItem(1) # Reset deviceSelector to RAM
      return False

    # no file name?
    if len(self.OriginEdit.text()) == 0:
      self.errorBox("You must define a valid origin file to upload.")
      return False

    fName = str(self.OriginEdit.text())
    if not os.path.exists(fName):
      self.errorBox("File %s does not exist. Is this a full pathname?" % fName)
      return False

    return True

    
  def downloadConsistent(self):
    """
        Several consistency checks are done:
        a) If there is nothing in the destination box, emit an errorbox and return
    """
    fName = str(self.DestinationEdit.text())
    # no file name?
    if len(fName) == 0:
      self.errorBox("You must define a valid target filename to which to download.")
      return False

    if os.path.exists(fName):
      m = QMessageBox( 'File exists, overwrite?',
                       'File %s exists.  Do you wish to overwrite this file?' % fName,
                       QMessageBox.Question,
                       QMessageBox.Yes,
                       QMessageBox.No | QMessageBox.Default,
                       QMessageBox.NoButton,
                       self,
                       None,
                       True )
      if m.exec_loop() == QMessageBox.No:
        return False

    return True
    



  def errorBox(self, msg):
    """ Dumb error message box.  Pops open a QMessageBox with CRITICAL state.

    \param msg   Any text.
    """
    
    m = QMessageBox( 'Error in FileTool:',
                     msg,
                     QMessageBox.Critical,
                     QMessageBox.Ok,
                     QMessageBox.NoButton,
                     QMessageBox.NoButton,
                     self,
                     None,
                     False )
    m.show()

  def __fid(self):
    """Parse the current settings into a file ID and return it

    \return A FswFileID object
    """

    return FswFileID( FSW_DEVICE_NAMES.index(str(self.DeviceSelector.currentText()).lower()),
                     self.DirSelector.value(),
                     self.FileNoSelector.value())




if __name__ == "__main__":

  

  a = QApplication(sys.argv)
  QObject.connect(a,SIGNAL("lastWindowClosed()"),a,SLOT("quit()"))
  w = FileToolImpl(None)
  a.setMainWidget(w)
  w.show()
  a.exec_loop()

---