← Back to branch summary

~ubuntu-branches/ubuntu/saucy/hplip/saucy-proposed

« back to all changes in this revision

Viewing changes to .pc/hp-check-groups.dpatch/check.py

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2012-05-26 11:20:39 UTC
  • mfrom: (1.5.6) (31.1.3 precise)
  • Revision ID: package-import@ubuntu.com-20120526112039-bevxczegxnbyr5m7
Tags: 3.12.4-1
http://bugs.debian.org/667828
http://bugs.debian.org/583273
http://bugs.debian.org/666544
* New upstream release
* Switch to source/format 3.0 (quilt) - drop dpatch
* Refreshed debian/patches
* dh_autoreconf debian/autogen.sh & set local-options single-debian-patch
* Update to debian/compat -> 9
* Fix "hardened build flags" patch from Moritz - thanks (Closes: #667828)
* Fix "duplex descriptor uninitialized" patch from Matej (Closes: #583273)
* Fix "please migrate to kde-runtime" patch from Pino (Closes: #666544)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/hp-check-groups.dpatch/check.py
 
1
#!/usr/bin/env python
 
2
# -*- coding: utf-8 -*-
 
3
#
 
4
# (c) Copyright 2003-2009 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
 
 
23
__version__ = '14.3'
 
24
__title__ = 'Dependency/Version Check Utility'
 
25
__mod__ = 'hp-check'
 
26
__doc__ = """Check the existence and versions of HPLIP dependencies. (Run as 'python ./check.py' from the HPLIP tarball before installation.)"""
 
27
 
 
28
# Std Lib
 
29
import sys
 
30
import os
 
31
import getopt
 
32
import commands
 
33
import re
 
34
 
 
35
# Local
 
36
from base.g import *
 
37
from base import utils, tui, models
 
38
from installer import dcheck
 
39
from installer.core_install import *
 
40
 
 
41
device_avail = False
 
42
try:
 
43
    from base import device, pml
 
44
    # This can fail due to hpmudext not being present
 
45
except ImportError:
 
46
    log.debug("Device library is not avail.")
 
47
else:
 
48
    device_avail = True
 
49
 
 
50
 
 
51
USAGE = [(__doc__, "", "name", True),
 
52
         ("Usage: %s [OPTIONS]" % __mod__, "", "summary", True),
 
53
         utils.USAGE_OPTIONS,
 
54
         ("Compile-time check:", "-c or --compile", "option", False),
 
55
         ("Run-time check:", "-r or --run", "option", False),
 
56
         ("Compile and run-time checks:", "-b or --both (default)", "option", False),
 
57
         utils.USAGE_LOGGING1, utils.USAGE_LOGGING2, utils.USAGE_LOGGING3,
 
58
         utils.USAGE_LOGGING_PLAIN,
 
59
         utils.USAGE_HELP,
 
60
         utils.USAGE_NOTES,
 
61
         ("1. For checking for the proper build environment for the HPLIP supplied tarball (.tar.gz or .run),", "", "note", False),
 
62
         ("use the --compile or --both switches.", "", "note", False),
 
63
         ("2. For checking for the proper runtime environment for a distro supplied package (.deb, .rpm, etc),", "", "note", False),
 
64
         ("use the --runtime switch.", "", "note", False),
 
65
        ]
 
66
 
 
67
def usage(typ='text'):
 
68
    if typ == 'text':
 
69
        utils.log_title(__title__, __version__)
 
70
 
 
71
    utils.format_text(USAGE, typ, __title__, __mod__, __version__)
 
72
    sys.exit(0)
 
73
 
 
74
 
 
75
build_str = "HPLIP will not build, install, and/or function properly without this dependency."
 
76
 
 
77
pat_deviceuri = re.compile(r"""(.*):/(.*?)/(\S*?)\?(?:serial=(\S*)|device=(\S*)|ip=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}[^&]*)|zc=(\S+))(?:&port=(\d))?""", re.I)
 
78
#pat_deviceuri = re.compile(r"""(.*):/(.*?)/(\S*?)\?(?:serial=(\S*)|device=(\S*)|ip=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}[^&]*))(?:&port=(\d))?""", re.I)
 
79
 
 
80
pat_cups_error_log = re.compile("""^loglevel\s?(debug|debug2|warn|info|error|none)""", re.I)
 
81
 
 
82
 
 
83
def parseDeviceURI(device_uri):
 
84
    m = pat_deviceuri.match(device_uri)
 
85
 
 
86
    if m is None:
 
87
        raise Error(ERROR_INVALID_DEVICE_URI)
 
88
 
 
89
    back_end = m.group(1).lower() or ''
 
90
    is_hp = (back_end in ('hp', 'hpfax', 'hpaio'))
 
91
    bus = m.group(2).lower() or ''
 
92
 
 
93
    if bus not in ('usb', 'net', 'bt', 'fw', 'par'):
 
94
        raise Error(ERROR_INVALID_DEVICE_URI)
 
95
 
 
96
    model = m.group(3) or ''
 
97
    serial = m.group(4) or ''
 
98
    dev_file = m.group(5) or ''
 
99
    host = m.group(6) or ''
 
100
    zc = ''
 
101
    if not host:
 
102
        zc = host = m.group(7) or ''
 
103
    port = m.group(8) or 1
 
104
 
 
105
    if bus == 'net':
 
106
        try:
 
107
            port = int(port)
 
108
        except (ValueError, TypeError):
 
109
            port = 1
 
110
 
 
111
        if port == 0:
 
112
            port = 1
 
113
 
 
114
#   log.debug("%s: back_end '%s' is_hp '%s' bus '%s' model '%s' serial '%s' dev_file '%s' host '%s' zc '%s' port '%s' " %
 
115
#       (device_uri, back_end, is_hp, bus, model, serial, dev_file, host, zc, port))
 
116
 
 
117
    return back_end, is_hp, bus, model, serial, dev_file, host, zc, port
 
118
 
 
119
num_errors = 0
 
120
fmt = True
 
121
overall_commands_to_run = []
 
122
time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
 
123
 
 
124
try:
 
125
    log.set_module(__mod__)
 
126
 
 
127
    try:
 
128
        opts, args = getopt.getopt(sys.argv[1:], 'hl:gtcrb',
 
129
            ['help', 'help-rest', 'help-man', 'help-desc', 'logging=',
 
130
             'run', 'runtime', 'compile', 'both'])
 
131
 
 
132
    except getopt.GetoptError, e:
 
133
        log.error(e.msg)
 
134
        usage()
 
135
        sys.exit(1)
 
136
 
 
137
    if os.getenv("HPLIP_DEBUG"):
 
138
        log.set_level('debug')
 
139
 
 
140
    log_level = 'info'
 
141
 
 
142
    for o, a in opts:
 
143
        if o in ('-h', '--help'):
 
144
            usage()
 
145
 
 
146
        elif o == '--help-rest':
 
147
            usage('rest')
 
148
 
 
149
        elif o == '--help-man':
 
150
            usage('man')
 
151
 
 
152
        elif o == '--help-desc':
 
153
            print __doc__,
 
154
            sys.exit(0)
 
155
 
 
156
        elif o in ('-l', '--logging'):
 
157
            log_level = a.lower().strip()
 
158
 
 
159
        elif o == '-g':
 
160
            log_level = 'debug'
 
161
 
 
162
        elif o == '-t':
 
163
            fmt = False
 
164
 
 
165
        elif o in ('-c', '--compile'):
 
166
            time_flag = DEPENDENCY_COMPILE_TIME
 
167
 
 
168
        elif o in ('-r', '--runtime', '--run'):
 
169
            time_flag = DEPENDENCY_RUN_TIME
 
170
 
 
171
        elif o in ('-b', '--both'):
 
172
            time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
 
173
 
 
174
    if not log.set_level(log_level):
 
175
        usage()
 
176
 
 
177
    if not fmt:
 
178
        log.no_formatting()
 
179
 
 
180
    utils.log_title(__title__, __version__)
 
181
 
 
182
    log.info(log.bold("Note: hp-check can be run in three modes:"))
 
183
 
 
184
    for l in tui.format_paragraph("1. Compile-time check mode (-c or --compile): Use this mode before compiling the HPLIP supplied tarball (.tar.gz or .run) to determine if the proper dependencies are installed to successfully compile HPLIP."):
 
185
        log.info(l)
 
186
 
 
187
    for l in tui.format_paragraph("2. Run-time check mode (-r or --run): Use this mode to determine if a distro supplied package (.deb, .rpm, etc) or an already built HPLIP supplied tarball has the proper dependencies installed to successfully run."):
 
188
        log.info(l)
 
189
 
 
190
    for l in tui.format_paragraph("3. Both compile- and run-time check mode (-b or --both) (Default): This mode will check both of the above cases (both compile- and run-time dependencies)."):
 
191
        log.info(l)
 
192
 
 
193
    log.info()
 
194
 
 
195
    log_file = os.path.normpath('./hp-check.log')
 
196
    log.info(log.bold("Saving output in log file: %s" % log_file))
 
197
    log.debug("Log file=%s" % log_file)
 
198
    if os.path.exists(log_file):
 
199
        os.remove(log_file)
 
200
 
 
201
    log.set_logfile(log_file)
 
202
    log.set_where(log.LOG_TO_CONSOLE_AND_FILE)
 
203
 
 
204
    log.info("\nInitializing. Please wait...")
 
205
    core =  CoreInstall(MODE_CHECK)
 
206
    core.init()
 
207
    core.set_plugin_version()
 
208
 
 
209
    tui.header("SYSTEM INFO")
 
210
 
 
211
    log.info(log.bold("Basic system information:"))
 
212
    log.info(core.sys_uname_info)
 
213
 
 
214
    log.info()
 
215
    log.info(log.bold("Distribution:"))
 
216
    log.info("%s %s" % (core.distro_name, core.distro_version))
 
217
 
 
218
    #log.info(log.bold("\nHPOJ running?"))
 
219
 
 
220
    #if core.hpoj_present:
 
221
        #log.error("Yes, HPOJ is running. HPLIP is not compatible with HPOJ. To run HPLIP, please remove HPOJ.")
 
222
        #num_errors += 1
 
223
    #else:
 
224
        #log.info("No, HPOJ is not running (OK).")
 
225
 
 
226
 
 
227
    log.info()
 
228
    log.info(log.bold("Checking Python version..."))
 
229
    ver = sys.version_info
 
230
    log.debug("sys.version_info = %s" % repr(ver))
 
231
    ver_maj = ver[0]
 
232
    ver_min = ver[1]
 
233
    ver_pat = ver[2]
 
234
 
 
235
    if ver_maj == 2:
 
236
        if ver_min >= 1:
 
237
            log.info("OK, version %d.%d.%d installed" % ver[:3])
 
238
        else:
 
239
            log.error("Version %d.%d.%d installed. Please update to Python >= 2.1" % ver[:3])
 
240
            sys.exit(1)
 
241
 
 
242
    ui_toolkit = sys_conf.get('ui_toolkit', 'qt4')
 
243
    if  ui_toolkit == 'qt3':
 
244
        log.info()
 
245
        log.info(log.bold("Checking PyQt 3.x version..."))
 
246
 
 
247
        # PyQt 3
 
248
        try:
 
249
            import qt
 
250
        except ImportError:
 
251
            num_errors += 1
 
252
            log.error("NOT FOUND OR FAILED TO LOAD!")
 
253
        else:
 
254
            # check version of Qt
 
255
            qtMajor = int(qt.qVersion().split('.')[0])
 
256
 
 
257
            if qtMajor < MINIMUM_QT_MAJOR_VER:
 
258
                log.error("Incorrect version of Qt installed. Ver. 3.0.0 or greater required.")
 
259
            else:
 
260
                #check version of PyQt
 
261
                try:
 
262
                    pyqtVersion = qt.PYQT_VERSION_STR
 
263
                except AttributeError:
 
264
                    pyqtVersion = qt.PYQT_VERSION
 
265
 
 
266
                while pyqtVersion.count('.') < 2:
 
267
                    pyqtVersion += '.0'
 
268
 
 
269
                (maj_ver, min_ver, pat_ver) = pyqtVersion.split('.')
 
270
 
 
271
                if pyqtVersion.find('snapshot') >= 0:
 
272
                    log.error("A non-stable snapshot version of PyQt is installed (%s)." % pyqtVersion)
 
273
                    num_errors += 1
 
274
                else:
 
275
                    try:
 
276
                        maj_ver = int(maj_ver)
 
277
                        min_ver = int(min_ver)
 
278
                        pat_ver = int(pat_ver)
 
279
                    except ValueError:
 
280
                        maj_ver, min_ver, pat_ver = 0, 0, 0
 
281
 
 
282
                    if maj_ver < MINIMUM_PYQT_MAJOR_VER or \
 
283
                        (maj_ver == MINIMUM_PYQT_MAJOR_VER and min_ver < MINIMUM_PYQT_MINOR_VER):
 
284
                        num_errors += 1
 
285
                        log.error("HPLIP may not function properly with the version of PyQt that is installed (%d.%d.%d)." % (maj_ver, min_ver, pat_ver))
 
286
                        log.error("Ver. %d.%d or greater required." % (MINIMUM_PYQT_MAJOR_VER, MINIMUM_PYQT_MINOR_VER))
 
287
                    else:
 
288
                        log.info("OK, version %d.%d installed." % (maj_ver, min_ver))
 
289
            del qt
 
290
 
 
291
 
 
292
    else:
 
293
 
 
294
        log.info()
 
295
        log.info(log.bold("Checking PyQt 4.x version..."))
 
296
 
 
297
        # PyQt 4
 
298
        try:
 
299
            import PyQt4
 
300
        except ImportError:
 
301
            num_errors += 1
 
302
            log.error("NOT FOUND OR FAILED TO LOAD!")
 
303
        else:
 
304
            from PyQt4 import QtCore
 
305
            log.info("OK, version %s installed." % QtCore.PYQT_VERSION_STR)
 
306
 
 
307
 
 
308
#    log.info()
 
309
#    log.info(log.bold("Checking SIP version..."))
 
310
#
 
311
#    sip_ver = None
 
312
#    try:
 
313
#        import pyqtconfig
 
314
#    except ImportError:
 
315
#        pass
 
316
#    else:
 
317
#        sip_ver = pyqtconfig.Configuration().sip_version_str
 
318
#
 
319
#    if sip_ver is not None:
 
320
#        log.info("OK, Version %s installed" % sip_ver)
 
321
#    else:
 
322
#        num_errors += 1
 
323
#        log.error("SIP not installed or version not found.")
 
324
 
 
325
    log.info()
 
326
    log.info(log.bold("Checking for CUPS..."))
 
327
    cups_ok = True
 
328
 
 
329
    status, output = utils.run('lpstat -r')
 
330
    if status == 0:
 
331
        log.info("Status: %s" % output.strip())
 
332
    else:
 
333
        log.error("Status: (Not available. CUPS may not be installed or not running.)")
 
334
        cups_ok = False
 
335
        num_errors += 1
 
336
 
 
337
    if cups_ok:
 
338
        status, output = utils.run('cups-config --version')
 
339
        if status == 0:
 
340
            log.info("Version: %s" % output.strip())
 
341
        else:
 
342
            log.warn("Version: (cups-config) Not available. Unable to determine installed version of CUPS.)")
 
343
 
 
344
    if cups_ok:
 
345
        cups_conf = '/etc/cups/cupsd.conf'
 
346
 
 
347
        try:
 
348
            f = file(cups_conf, 'r')
 
349
        except (IOError, OSError):
 
350
            log.warn("%s file not found or not accessible." % cups_conf)
 
351
        else:
 
352
            for l in f:
 
353
                m = pat_cups_error_log.match(l)
 
354
                if m is not None:
 
355
                    level = m.group(1).lower()
 
356
                    log.info("error_log is set to level: %s" % level)
 
357
 
 
358
                    #if level not in ('debug', 'debug2'):
 
359
                        #log.note("For troubleshooting printing issues, it is best to have the CUPS 'LogLevel'")
 
360
                        #log.note("set to 'debug'. To set the LogLevel to debug, edit the file %s (as root)," % cups_conf)
 
361
                        #log.note("and change the line near the top of the file that begins with 'LogLevel' to read:")
 
362
                        #log.note("LogLevel debug")
 
363
                        #log.note("Save the file and then restart CUPS (see your OS/distro docs on how to restart CUPS).")
 
364
                        #log.note("Now, when you print, helpful debug information will be saved to the file:")
 
365
                        #log.note("/var/log/cups/error_log")
 
366
                        #log.note("You can monitor this file by running this command in a console/shell:")
 
367
                        #log.note("tail -f /var/log/cups/error_log")
 
368
 
 
369
                    break
 
370
 
 
371
 
 
372
    log.info()
 
373
 
 
374
    log.info(log.bold("Checking for dbus/python-dbus..."))
 
375
 
 
376
    if dcheck.check_ps(['dbus-daemon']):
 
377
        log.info("dbus daemon is running.")
 
378
    else:
 
379
        log.warn("dbus daemon is not running.")
 
380
 
 
381
    try:
 
382
        import dbus
 
383
        try:
 
384
            log.info("python-dbus version: %s" % dbus.__version__)
 
385
        except AttributeError:
 
386
            try:
 
387
                log.info("python-dbus version: %s" % '.'.join([str(x) for x in dbus.version]))
 
388
            except AttributeError:
 
389
                log.warn("python-dbus imported OK, but unknown version.")
 
390
    except ImportError:
 
391
        log.warn("python-dbus not installed.")
 
392
 
 
393
    log.info()
 
394
 
 
395
 
 
396
    if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME:
 
397
        tui.header("COMPILE AND RUNTIME DEPENDENCIES")
 
398
        log.note("To check for compile-time only dependencies, re-run hp-check with the -c parameter (ie, hp-check -c).")
 
399
        log.note("To check for run-time only dependencies, re-run hp-check with the -r parameter (ie, hp-check -r).")
 
400
 
 
401
    elif time_flag == DEPENDENCY_COMPILE_TIME:
 
402
        tui.header("COMPILE TIME DEPENDENCIES")
 
403
 
 
404
    elif time_flag == DEPENDENCY_RUN_TIME:
 
405
        tui.header("RUNTIME DEPENDENCIES")
 
406
 
 
407
    log.info()
 
408
 
 
409
    dd = core.dependencies.keys()
 
410
 
 
411
    status, output = utils.run('cups-config --version')
 
412
    import string
 
413
    if status == 0 and (string.count(output, '.') == 1 or string.count(output, '.') == 2):
 
414
        if string.count(output, '.') == 1:
 
415
            major, minor = string.split(output, '.', 2)
 
416
        if string.count(output, '.') == 2:
 
417
            major, minor, release = string.split(output, '.', 3)
 
418
        if len(minor) > 1 and minor[1] >= '0' and minor[1] <= '9':
 
419
            minor = ((ord(minor[0]) - ord('0')) * 10) + (ord(minor[1]) - ord('0'))
 
420
        else:
 
421
            minor = ord(minor[0]) - ord('0')
 
422
        if major > '1' or (major == '1' and minor >= 4):
 
423
            dd.remove('cups-ddk')
 
424
 
 
425
    dd.sort()
 
426
    for d in dd:
 
427
        if (d == 'pyqt' and ui_toolkit != 'qt3') or \
 
428
           (d == 'pyqt4' and ui_toolkit != 'qt4'):
 
429
            continue
 
430
 
 
431
        log.debug("***")
 
432
 
 
433
        if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME or time_flag == core.dependencies[d][4]:
 
434
 
 
435
            log.info(log.bold("Checking for dependency: %s..." % core.dependencies[d][2]))
 
436
 
 
437
            if core.have_dependencies[d]:
 
438
                log.info("OK, found.")
 
439
            else:
 
440
                num_errors += 1
 
441
 
 
442
                if core.dependencies[d][4] == DEPENDENCY_RUN_AND_COMPILE_TIME:
 
443
                    s = ''
 
444
                elif core.dependencies[d][4] == DEPENDENCY_COMPILE_TIME:
 
445
                    s = '/COMPILE TIME ONLY'
 
446
 
 
447
                elif core.dependencies[d][4] == DEPENDENCY_RUN_TIME:
 
448
                    s = '/RUNTIME ONLY'
 
449
 
 
450
                if core.dependencies[d][0]:
 
451
                    log.error("NOT FOUND! This is a REQUIRED%s dependency. Please make sure that this dependency is installed before installing or running HPLIP." % s)
 
452
                else:
 
453
                    log.warn("NOT FOUND! This is an OPTIONAL%s dependency. Some HPLIP functionality may not function properly." %s)
 
454
 
 
455
                if core.distro_supported():
 
456
                    packages_to_install, commands = core.get_dependency_data(d)
 
457
 
 
458
                    commands_to_run = []
 
459
 
 
460
                    if packages_to_install:
 
461
                        package_mgr_cmd = core.get_distro_data('package_mgr_cmd')
 
462
 
 
463
                        if package_mgr_cmd:
 
464
                            packages_to_install = ' '.join(packages_to_install)
 
465
                            commands_to_run.append(utils.cat(package_mgr_cmd))
 
466
 
 
467
                    if commands:
 
468
                        commands_to_run.extend(commands)
 
469
 
 
470
                    overall_commands_to_run.extend(commands_to_run)
 
471
 
 
472
                    if len(commands_to_run) == 1:
 
473
                        log.info("To install this dependency, execute this command:")
 
474
                        log.info(commands_to_run[0])
 
475
 
 
476
                    elif len(commands_to_run) > 1:
 
477
                        log.info("To install this dependency, execute these commands:")
 
478
                        for c in commands_to_run:
 
479
                            log.info(c)
 
480
 
 
481
 
 
482
            log.info()
 
483
 
 
484
    if time_flag in (DEPENDENCY_RUN_TIME, DEPENDENCY_RUN_AND_COMPILE_TIME):
 
485
        tui.header("HPLIP INSTALLATION")
 
486
 
 
487
        scanning_enabled = utils.to_bool(sys_conf.get('configure', 'scanner-build', '0'))
 
488
 
 
489
        log.info()
 
490
        log.info(log.bold("Currently installed HPLIP version..."))
 
491
        v = sys_conf.get('hplip', 'version')
 
492
        home = sys_conf.get('dirs', 'home')
 
493
 
 
494
        if v:
 
495
            log.info("HPLIP %s currently installed in '%s'." % (v, home))
 
496
 
 
497
            log.info()
 
498
            log.info(log.bold("Current contents of '/etc/hp/hplip.conf' file:"))
 
499
            try:
 
500
                output = file('/etc/hp/hplip.conf', 'r').read()
 
501
            except (IOError, OSError), e:
 
502
                log.error("Could not access file: %s" % e.strerror)
 
503
            else:
 
504
                log.info(output)
 
505
 
 
506
            log.info()
 
507
            log.info(log.bold("Current contents of '/var/lib/hp/hplip.state' file:"))
 
508
            try:
 
509
                output = file(os.path.expanduser('/var/lib/hp/hplip.state'), 'r').read()
 
510
            except (IOError, OSError), e:
 
511
                log.info("Plugins are not installed. Could not access file: %s" % e.strerror)
 
512
            else:
 
513
                log.info(output)
 
514
 
 
515
            log.info()
 
516
            log.info(log.bold("Current contents of '~/.hplip/hplip.conf' file:"))
 
517
            try:
 
518
                output = file(os.path.expanduser('~/.hplip/hplip.conf'), 'r').read()
 
519
            except (IOError, OSError), e:
 
520
                log.error("Could not access file: %s" % e.strerror)
 
521
            else:
 
522
                log.info(output)
 
523
 
 
524
        else:
 
525
            log.info("Not found.")
 
526
 
 
527
 
 
528
        if device_avail:
 
529
            #if prop.par_build:
 
530
                #tui.header("DISCOVERED PARALLEL DEVICES")
 
531
 
 
532
                #devices = device.probeDevices(['par'])
 
533
 
 
534
                #if devices:
 
535
                    #f = tui.Formatter()
 
536
                    #f.header = ("Device URI", "Model")
 
537
 
 
538
                    #for d, dd in devices.items():
 
539
                        #f.add((d, dd[0]))
 
540
 
 
541
                    #f.output()
 
542
 
 
543
                #else:
 
544
                    #log.info("No devices found.")
 
545
 
 
546
                    #if not core.have_dependencies['ppdev']:
 
547
                        #log.error("'ppdev' kernel module not loaded.")
 
548
 
 
549
            if prop.usb_build:
 
550
                tui.header("DISCOVERED USB DEVICES")
 
551
 
 
552
                devices = device.probeDevices(['usb'])
 
553
 
 
554
                if devices:
 
555
                    f = tui.Formatter()
 
556
                    f.header = ("Device URI", "Model")
 
557
 
 
558
                    for d, dd in devices.items():
 
559
                        f.add((d, dd[0]))
 
560
 
 
561
                    f.output()
 
562
 
 
563
                else:
 
564
                    log.info("No devices found.")
 
565
 
 
566
 
 
567
        tui.header("INSTALLED CUPS PRINTER QUEUES")
 
568
 
 
569
        lpstat_pat = re.compile(r"""(\S*): (.*)""", re.IGNORECASE)
 
570
        status, output = utils.run('lpstat -v')
 
571
        log.info()
 
572
 
 
573
        cups_printers = []
 
574
        for p in output.splitlines():
 
575
            try:
 
576
                match = lpstat_pat.search(p)
 
577
                printer_name = match.group(1)
 
578
                device_uri = match.group(2)
 
579
                cups_printers.append((printer_name, device_uri))
 
580
            except AttributeError:
 
581
                pass
 
582
 
 
583
        log.debug(cups_printers)
 
584
 
 
585
        if cups_printers:
 
586
            #non_hp = False
 
587
            for p in cups_printers:
 
588
                printer_name, device_uri = p
 
589
 
 
590
                if device_uri.startswith("cups-pdf:/") or \
 
591
                    device_uri.startswith('ipp://'):
 
592
                    continue
 
593
 
 
594
                try:
 
595
                    back_end, is_hp, bus, model, serial, dev_file, host, zc, port = \
 
596
                        parseDeviceURI(device_uri)
 
597
                except Error:
 
598
                    back_end, is_hp, bus, model, serial, dev_file, host, zc, port = \
 
599
                        '', False, '', '', '', '', '', '', 1
 
600
 
 
601
                #print back_end, is_hp, bus, model, serial, dev_file, host, zc, port
 
602
 
 
603
                log.info(log.bold(printer_name))
 
604
                log.info(log.bold('-'*len(printer_name)))
 
605
 
 
606
                x = "Unknown"
 
607
                if back_end == 'hpfax':
 
608
                    x = "Fax"
 
609
                elif back_end == 'hp':
 
610
                    x = "Printer"
 
611
 
 
612
                log.info("Type: %s" % x)
 
613
 
 
614
                #if is_hp:
 
615
                #    x = 'Yes, using the %s: CUPS backend.' % back_end
 
616
                #else:
 
617
                #    x = 'No, not using the hp: or hpfax: CUPS backend.'
 
618
                #    non_hp = True
 
619
 
 
620
                #log.info("Installed in HPLIP?: %s" % x)
 
621
                log.info("Device URI: %s" % device_uri)
 
622
 
 
623
                ppd = os.path.join('/etc/cups/ppd', printer_name + '.ppd')
 
624
 
 
625
                if os.path.exists(ppd):
 
626
                    log.info("PPD: %s" % ppd)
 
627
                    nickname_pat = re.compile(r'''\*NickName:\s*\"(.*)"''', re.MULTILINE)
 
628
 
 
629
                    f = file(ppd, 'r').read(4096)
 
630
 
 
631
                    try:
 
632
                        desc = nickname_pat.search(f).group(1)
 
633
                    except AttributeError:
 
634
                        desc = ''
 
635
 
 
636
                    log.info("PPD Description: %s" % desc)
 
637
 
 
638
                    status, output = utils.run('lpstat -p%s' % printer_name)
 
639
                    log.info("Printer status: %s" % output.replace("\n", ""))
 
640
 
 
641
                    if back_end == 'hpfax' and not 'HP Fax' in desc:
 
642
                        num_errors += 1
 
643
                        log.error("Incorrect PPD file for fax queue '%s'. Fax queues must use 'HP-Fax-hplip.ppd'." % printer_name)
 
644
 
 
645
                    elif back_end == 'hp' and 'HP Fax' in desc:
 
646
                        num_errors += 1
 
647
                        log.error("Incorrect PPD file for a print queue '%s'. Print queues must not use 'HP-Fax-hplip.ppd'." % printer_name)
 
648
 
 
649
                    elif back_end not in ('hp', 'hpfax'):
 
650
                        log.warn("Printer is not HPLIP installed. Printers must use the hp: or hpfax: CUPS backend to function in HPLIP.")
 
651
                        num_errors += 1
 
652
 
 
653
                if device_avail and is_hp:
 
654
                    d = None
 
655
                    try:
 
656
                        try:
 
657
                            d = device.Device(device_uri)
 
658
                        except Error:
 
659
                            log.error("Device initialization failed.")
 
660
                            continue
 
661
 
 
662
                        plugin = d.mq.get('plugin', PLUGIN_NONE)
 
663
                        if plugin in (PLUGIN_REQUIRED, PLUGIN_OPTIONAL):
 
664
                            plugin_sts = core.check_for_plugin()
 
665
                            if plugin_sts == PLUGIN_INSTALLED:
 
666
                                if plugin == PLUGIN_REQUIRED:
 
667
                                    log.info("Required plug-in status: Installed")
 
668
                                else:
 
669
                                    log.info("Optional plug-in status: Installed")
 
670
                            elif plugin_sts == PLUGIN_VERSION_MISMATCH:
 
671
                                num_errors += 1
 
672
                                log.warn("Optional plug-in status: Version mismatch")
 
673
                                
 
674
                            else:
 
675
                                num_errors += 1
 
676
                                if plugin == PLUGIN_REQUIRED:
 
677
                                    log.error("Required plug-in status: Not installed")
 
678
                                else:
 
679
                                    log.warn("Optional plug-in status: Not installed")
 
680
 
 
681
 
 
682
                        if bus in ('par', 'usb'):
 
683
                            try:
 
684
                                d.open()
 
685
                            except Error, e:
 
686
                                log.error(e.msg)
 
687
                                deviceid = ''
 
688
                            else:
 
689
                                deviceid = d.getDeviceID()
 
690
                                log.debug(deviceid)
 
691
 
 
692
                            #print deviceid
 
693
                            if not deviceid:
 
694
                                log.error("Communication status: Failed")
 
695
                                #error_code = pml.ERROR_COMMAND_EXECUTION
 
696
                                num_errors += 1
 
697
                            else:
 
698
                                log.info("Communication status: Good")
 
699
 
 
700
                        elif bus == 'net':
 
701
                            try:
 
702
                                error_code, deviceid = d.getPML(pml.OID_DEVICE_ID)
 
703
                            except Error:
 
704
                                #log.error("Communication with device failed.")
 
705
                                #error_code = pml.ERROR_COMMAND_EXECUTION
 
706
                                pass
 
707
 
 
708
                            #print error_code
 
709
                            if not deviceid:
 
710
                                log.error("Communication status: Failed")
 
711
                                num_errors += 1
 
712
                            else:
 
713
                                log.info("Communication status: Good")
 
714
 
 
715
                    finally:
 
716
                        if d is not None:
 
717
                            d.close()
 
718
 
 
719
                log.info()
 
720
 
 
721
 
 
722
 
 
723
        else:
 
724
            log.warn("No queues found.")
 
725
 
 
726
        if scanning_enabled:
 
727
            tui.header("SANE CONFIGURATION")
 
728
            log.info(log.bold("'hpaio' in '/etc/sane.d/dll.conf'..."))
 
729
            try:
 
730
                f = file('/etc/sane.d/dll.conf', 'r')
 
731
            except IOError:
 
732
                log.error("'/etc/sane.d/dll.conf' not found. Is SANE installed?")
 
733
                num_errors += 1
 
734
            else:
 
735
                found = False
 
736
                for line in f:
 
737
                    lineNoSpace = re.sub(r'\s', '', line) 
 
738
                    hpaiomatched=re.match('hpaio',lineNoSpace)
 
739
#                   if 'hpaio' in line:
 
740
                    if hpaiomatched:
 
741
                        found = True
 
742
 
 
743
                if found:
 
744
                    log.info("OK, found. SANE backend 'hpaio' is properly set up.")
 
745
                else:
 
746
                    num_errors += 1
 
747
                    log.error("Not found. SANE backend 'hpaio' NOT properly setup (needs to be added to /etc/sane.d/dll.conf).")
 
748
 
 
749
                log.info()
 
750
                log.info(log.bold("Checking output of 'scanimage -L'..."))
 
751
                if utils.which('scanimage'):
 
752
                    status, output = utils.run("scanimage -L")
 
753
                    log.info(output)
 
754
                else:
 
755
                    log.error("scanimage not found.")
 
756
 
 
757
        tui.header("PYTHON EXTENSIONS")
 
758
 
 
759
        log.info(log.bold("Checking 'cupsext' CUPS extension..."))
 
760
        try:
 
761
            import cupsext
 
762
        except ImportError:
 
763
            num_errors += 1
 
764
            log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of cupsext.")
 
765
        else:
 
766
            log.info("OK, found.")
 
767
 
 
768
        log.info()
 
769
        log.info(log.bold("Checking 'pcardext' Photocard extension..."))
 
770
        try:
 
771
            import pcardext
 
772
        except ImportError:
 
773
            num_errors += 1
 
774
            log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of pcardext.")
 
775
        else:
 
776
            log.info("OK, found.")
 
777
 
 
778
        log.info()
 
779
        log.info(log.bold("Checking 'hpmudext' I/O extension..."))
 
780
        try:
 
781
            import hpmudext
 
782
            hpmudext_avail = True
 
783
        except ImportError:
 
784
            hpmudext_avail = False
 
785
            num_errors += 1
 
786
            log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of hpmudext.")
 
787
        else:
 
788
            log.info("OK, found.")
 
789
 
 
790
        if scanning_enabled:
 
791
            log.info()
 
792
            log.info(log.bold("Checking 'scanext' SANE scanning extension..."))
 
793
            try:
 
794
                import scanext
 
795
            except ImportError:
 
796
                num_errors += 1
 
797
                log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of scanext.")
 
798
            else:
 
799
                log.info("OK, found.")
 
800
 
 
801
                log.info()
 
802
 
 
803
 
 
804
        if hpmudext_avail:
 
805
            lsusb = utils.which('lsusb')
 
806
            if lsusb:
 
807
                log.info()
 
808
 
 
809
                lsusb = os.path.join(lsusb, 'lsusb')
 
810
                status, output = utils.run("%s -d03f0:" % lsusb)
 
811
 
 
812
                if output:
 
813
                    tui.header("USB I/O SETUP")
 
814
                    log.info(log.bold("Checking for permissions of USB attached printers..."))
 
815
 
 
816
                    lsusb_pat = re.compile("""^Bus\s([0-9a-fA-F]{3,3})\sDevice\s([0-9a-fA-F]{3,3}):\sID\s([0-9a-fA-F]{4,4}):([0-9a-fA-F]{4,4})(.*)""", re.IGNORECASE)
 
817
                    log.debug(output)
 
818
 
 
819
                    for o in output.splitlines():
 
820
                        ok = True
 
821
                        match = lsusb_pat.search(o)
 
822
 
 
823
                        if match is not None:
 
824
                            bus, dev, vid, pid, mfg = match.groups()
 
825
                            log.info("\nHP Device 0x%x at %s:%s: " % (int(pid, 16), bus, dev))
 
826
                            result_code, deviceuri = hpmudext.make_usb_uri(bus, dev)
 
827
 
 
828
                            if result_code == hpmudext.HPMUD_R_OK:
 
829
                                log.info("    Device URI: %s" %  deviceuri)
 
830
                                d = None
 
831
                                try:
 
832
                                    d = device.Device(deviceuri)
 
833
                                except Error:
 
834
                                    continue
 
835
                                if not d.supported:
 
836
                                    continue
 
837
                            else:
 
838
                                log.warn("    Device URI: (Makeuri FAILED)")
 
839
                                continue
 
840
 
 
841
                            devnode = os.path.join("/", "dev", "bus", "usb", bus, dev)
 
842
 
 
843
                            if not os.path.exists(devnode):
 
844
                                devnode = os.path.join("/", "proc", "bus", "usb", bus, dev)
 
845
 
 
846
                            if os.path.exists(devnode):
 
847
                                log.info("    Device node: %s" % devnode)
 
848
 
 
849
                                st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, \
 
850
                                    st_size, st_atime, st_mtime, st_ctime = \
 
851
                                    os.stat(devnode)
 
852
 
 
853
                                log.info("    Mode: 0%o" % (st_mode & 0777))
 
854
 
 
855
                                getfacl = utils.which('getfacl')
 
856
                                if getfacl:
 
857
                                    getfacl = os.path.join(getfacl, "getfacl")
 
858
 
 
859
                                    status, output = utils.run("%s %s" % (getfacl, devnode))
 
860
 
 
861
                                    log.info(output)
 
862
 
 
863
    tui.header("USER GROUPS")
 
864
 
 
865
    groups = utils.which('groups')
 
866
    if groups:
 
867
        groups = os.path.join(groups, 'groups')
 
868
        status, output = utils.run(groups)
 
869
 
 
870
        if status == 0:
 
871
            log.info(output)
 
872
 
 
873
 
 
874
    tui.header("SUMMARY")
 
875
 
 
876
    if num_errors:
 
877
        if num_errors == 1:
 
878
            log.error("1 error or warning.")
 
879
        else:
 
880
            log.error("%d errors and/or warnings." % num_errors)
 
881
 
 
882
        if overall_commands_to_run:
 
883
            log.info()
 
884
            log.info(log.bold("Summary of needed commands to run to satisfy missing dependencies:"))
 
885
            for c in overall_commands_to_run:
 
886
                log.info(c)
 
887
 
 
888
        log.info()
 
889
        log.info("Please refer to the installation instructions at:")
 
890
        log.info("http://hplip.sourceforge.net/install/index.html\n")
 
891
 
 
892
    else:
 
893
        log.info(log.green("No errors or warnings."))
 
894
 
 
895
except KeyboardInterrupt:
 
896
    log.error("User exit")
 
897
 
 
898
log.info()
 
899
log.info("Done.")
 
900