home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / hplip / toolbox < prev    next >
Encoding:
Text File  |  2006-08-30  |  9.1 KB  |  327 lines
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # (c) Copyright 2003-2006 Hewlett-Packard Development Company, L.P.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19. #
  20. # Author: Don Welch
  21. #
  22. # Thanks to Henrique M. Holschuh <hmh@debian.org> for various security patches
  23. #
  24.  
  25. __version__ = '6.2'
  26. __title__ = 'HP Device Manager'
  27. __doc__ = "The HP Device Manager (aka Toolbox) for HPLIP supported devices. Provides status, tools, and supplies levels."
  28.  
  29. # Std Lib
  30. import sys
  31. import socket
  32. import os, os.path
  33. import getopt
  34. import signal
  35. import atexit
  36.  
  37. # Local
  38. from base.g import *
  39. import base.async_qt as async
  40. import base.utils as utils
  41. from base.msg import *
  42. from base import service
  43.  
  44. app = None
  45. client = None
  46. toolbox  = None
  47. hpiod_sock = None
  48.  
  49. # PyQt
  50. if not utils.checkPyQtImport():
  51.     log.error("PyQt/Qt initialization error. Please check install of PyQt/Qt and try again.")
  52.     sys.exit(0)
  53.  
  54. from qt import *
  55.  
  56. # UI Forms
  57. from ui.devmgr4 import devmgr4
  58.  
  59.  
  60. USAGE = [(__doc__, "", "name", True),
  61.          ("Usage: hp-toolbox [OPTIONS]", "", "summary", True),
  62.          utils.USAGE_OPTIONS,
  63.          utils.USAGE_LOGGING1, utils.USAGE_LOGGING2, utils.USAGE_LOGGING3,
  64.          utils.USAGE_HELP,
  65.          utils.USAGE_SEEALSO,
  66.          ("hp-info", "", "seealso", False),
  67.          ("hp-clean", "", "seealso", False),
  68.          ("hp-colorcal", "", "seealso", False),
  69.          ("hp-align", "", "seealso", False),
  70.          ("hp-print", "", "seealso", False),
  71.          ("hp-sendfax", "", "seealso", False),
  72.          ("hp-fab", "", "seealso", False),
  73.          ("hp-testpage", "", "seealso", False),
  74.         ]
  75.  
  76. def usage(typ='text'):
  77.     if typ == 'text':
  78.         utils.log_title(__title__, __version__)
  79.         
  80.     utils.format_text(USAGE, typ, __title__, 'hp-toolbox', __version__)
  81.     sys.exit(0)        
  82.  
  83.  
  84. class tbx_client(async.dispatcher):
  85.  
  86.     def __init__(self):
  87.         async.dispatcher.__init__(self)
  88.         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
  89.         try:
  90.             self.connect((prop.hpssd_host, prop.hpssd_port)) 
  91.         except socket.error:
  92.             log.error("Unable to connect to HPLIP I/O. Check and make sure HPLIP is running.")
  93.             raise Error(ERROR_UNABLE_TO_CONTACT_SERVICE)
  94.         
  95.         self.in_buffer = ""
  96.         self.out_buffer = ""
  97.         self.fields = {}
  98.         self.data = ''
  99.         self.error_dialog = None
  100.         self.toolbox_active = False
  101.         self.signal_exit = False
  102.  
  103.         # handlers for all the messages we expect to receive
  104.         self.handlers = {
  105.                         'eventgui' : self.handle_eventgui,
  106.                         'unknown' : self.handle_unknown,
  107.                         'exitguievent' : self.handle_exitguievent,
  108.                         }
  109.  
  110.         self.register_gui()
  111.  
  112.     def handle_read(self):
  113.         log.debug("Reading data on channel (%d)" % self._fileno)
  114.  
  115.         self.in_buffer = self.recv(prop.max_message_len)
  116.         log.debug(repr(self.in_buffer))
  117.  
  118.         if self.in_buffer == '':
  119.             return False
  120.  
  121.         remaining_msg = self.in_buffer
  122.  
  123.         while True:
  124.             try:
  125.                 self.fields, self.data, remaining_msg = parseMessage(remaining_msg)
  126.             except Error, e:
  127.                 log.debug(repr(self.in_buffer))
  128.                 log.warn("Message parsing error: %s (%d)" % (e.opt, e.msg))
  129.                 self.out_buffer = self.handle_unknown()
  130.                 log.debug(self.out_buffer)
  131.                 return True
  132.  
  133.             msg_type = self.fields.get('msg', 'unknown')
  134.             log.debug("%s %s %s" % ("*"*20, msg_type, "*"*20))
  135.             log.debug(repr(self.in_buffer))
  136.  
  137.             try:
  138.                 self.out_buffer = self.handlers.get(msg_type, self.handle_unknown)()
  139.             except Error:
  140.                 log.error("Unhandled exception during processing")
  141.  
  142.             if len(self.out_buffer): # data is ready for send
  143.                 self.sock_write_notifier.setEnabled(True)
  144.  
  145.             if not remaining_msg:
  146.                 break
  147.  
  148.         return True
  149.  
  150.     def handle_write(self):
  151.         if not len(self.out_buffer):
  152.             return
  153.  
  154.         log.debug("Sending data on channel (%d)" % self._fileno)
  155.         log.debug(repr(self.out_buffer))
  156.         
  157.         try:
  158.             sent = self.send(self.out_buffer)
  159.         except:
  160.             log.error("send() failed.")
  161.  
  162.         self.out_buffer = self.out_buffer[sent:]
  163.  
  164.  
  165.     def writable(self):
  166.         return not ((len(self.out_buffer) == 0)
  167.                      and self.connected)
  168.  
  169.     def handle_exitguievent(self):
  170.         self.signal_exit = True
  171.         if self.signal_exit:
  172.             if toolbox is not None:
  173.                 toolbox.close()
  174.             qApp.quit()
  175.  
  176.         return ''
  177.  
  178.     # EVENT
  179.     def handle_eventgui(self):
  180.         #global toolbox
  181.         if toolbox is not None:
  182.             try:
  183.                 job_id = self.fields['job-id']
  184.                 event_code = self.fields['event-code']
  185.                 event_type = self.fields['event-type']
  186.                 retry_timeout = self.fields['retry-timeout']
  187.                 lines = self.data.splitlines()
  188.                 error_string_short, error_string_long = lines[0], lines[1]
  189.                 device_uri = self.fields['device-uri']
  190.     
  191.                 log.debug("Event: %d '%s'" % (event_code, event_type))
  192.     
  193.                 toolbox.EventUI(event_code, event_type, error_string_short,
  194.                                  error_string_long, retry_timeout, job_id,
  195.                                  device_uri)
  196.     
  197.             except:
  198.                 log.exception()
  199.  
  200.         return ''
  201.  
  202.     def handle_unknown(self):
  203.         #return buildResultMessage('MessageError', None, ERROR_INVALID_MSG_TYPE)
  204.         return ''
  205.  
  206.     def handle_messageerror(self):
  207.         return ''
  208.  
  209.     def handle_close(self):
  210.         log.debug("closing channel (%d)" % self._fileno)
  211.         self.connected = False
  212.         async.dispatcher.close(self)
  213.  
  214.     def register_gui(self):
  215.         out_buffer = buildMessage("RegisterGUIEvent", None, {'username': prop.username, 'type':'tbx'})
  216.         self.send(out_buffer)
  217.  
  218. def toolboxCleanup():
  219.     pass
  220.  
  221. def handleEXIT():
  222.     if client is not None:
  223.         try:
  224.             client.close()
  225.         except:
  226.             pass
  227.             
  228.     if hpiod_sock is not None:
  229.         hpiod_sock.close()
  230.  
  231.     try:
  232.         app.quit()
  233.     except:
  234.         pass
  235.  
  236.  
  237. def main(args):
  238.     prop.prog = sys.argv[0]
  239.  
  240.     try:
  241.         opts, args = getopt.getopt(sys.argv[1:], 'l:hg', 
  242.             ['level=', 'help', 'help-rest', 'help-man'])
  243.  
  244.     except getopt.GetoptError:
  245.         usage()
  246.  
  247.     if os.getenv("HPLIP_DEBUG"):
  248.         log.set_level('debug')
  249.         
  250.         
  251.     for o, a in opts:
  252.         if o in ('-l', '--logging'):
  253.             log_level = a.lower().strip()
  254.             if not log.set_level(log_level):
  255.                 usage()
  256.                 
  257.         elif o == '-g':
  258.             log.set_level('debug')
  259.  
  260.         elif o in ('-h', '--help'):
  261.             usage()
  262.             
  263.         elif o == '--help-rest':
  264.             usage('rest')
  265.         
  266.         elif o == '--help-man':
  267.             usage('man')
  268.             
  269.     utils.log_title(__title__, __version__)
  270.  
  271.     # Security: Do *not* create files that other users can muck around with
  272.     os.umask (0077)
  273.  
  274.     global client
  275.     try:
  276.         client = tbx_client()
  277.     except Error:
  278.         log.error("Unable to create client object.")
  279.         sys.exit(1)
  280.     except socket.error:
  281.         log.error("Unable to connect to HPLIP I/O (hpiod).")
  282.         return 1
  283.         
  284.     log.debug("Connected to hpssd on %s:%d" % (prop.hpssd_host, prop.hpssd_port))
  285.     log.set_module('toolbox')
  286.     log.debug("Connected to hpssd on %s:%d" % (prop.hpssd_host, prop.hpssd_port))
  287.  
  288.     # create the main application object
  289.     global app
  290.     app = QApplication(sys.argv)
  291.  
  292.     hpiod_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  293.     try:
  294.         hpiod_sock.connect((prop.hpiod_host, prop.hpiod_port))
  295.     except socket.error:
  296.         log.error("Unable to connect to HPLIP I/O (hpiod).")
  297.         return 1
  298.     
  299.     log.debug("Connected to hpiod on %s:%d" % (prop.hpiod_host, prop.hpiod_port))
  300.     
  301.     global toolbox
  302.     toolbox = devmgr4(hpiod_sock, client.socket, toolboxCleanup)
  303.     app.setMainWidget(toolbox)
  304.  
  305.     toolbox.show()
  306.  
  307.     atexit.register(handleEXIT)
  308.     signal.signal(signal.SIGPIPE, signal.SIG_IGN)
  309.  
  310.     user_config = os.path.expanduser('~/.hplip.conf')
  311.     loc = utils.loadTranslators(app, user_config)
  312.  
  313.     try:
  314.         log.debug("Starting GUI loop...")
  315.         app.exec_loop()
  316.     except KeyboardInterrupt:
  317.         pass
  318.     except:
  319.         log.exception()
  320.  
  321.     handleEXIT()
  322.  
  323.     return 0
  324.  
  325. if __name__ == "__main__":
  326.     sys.exit(main(sys.argv[1:]))
  327.