← Back to branch summary

~ubuntu-branches/ubuntu/raring/hplip/raring

« back to all changes in this revision

Viewing changes to base/device.py

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2012-10-06 15:03:44 UTC
  • mfrom: (1.6.1) (20.1.16 quantal)
  • Revision ID: package-import@ubuntu.com-20121006150344-2p3xz26br0t3hu2q
Tags: 3.12.10-1
http://bugs.debian.org/683033
http://bugs.debian.org/687129
* New upstream release
  - Fixes "Network scanning fails (Closes: #683033)
* quilt refresh hplip-syslog-fix-debug-messages-to-error.dpatch
* Fix "error in clean build env" updated debian/rules (Closes: #687129)

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/device.py
94
94
dev_pat = re.compile(r"""/dev/.+""", re.IGNORECASE)
95
95
usb_pat = re.compile(r"""(\d+):(\d+)""", re.IGNORECASE)
96
96
 
 
97
### **********Lambda Function UniStar for checking type of arguments to constructor of class event*******************************
 
98
 
 
99
UniStr = lambda title: isinstance(title, str) and utils.xrstrip(title, '\x00')[:128] or utils.xrstrip(title, '\x00')[:128].encode('utf-8')
 
100
 
 
101
 
97
102
#
98
103
# Event Wrapper Class for pipe IPC
99
104
#
102
107
    def __init__(self, device_uri, printer_name, event_code,
103
108
                 username=prop.username, job_id=0, title='',
104
109
                 timedate=0):
105
 
 
106
 
        self.device_uri = unicode(utils.xrstrip(device_uri, '\x00'))[:128].encode('utf-8')
107
 
        self.printer_name = unicode(utils.xrstrip(printer_name, '\x00'))[:128].encode('utf-8')
 
110
       # UniStr = lambda title: isinstance(title, str) and utils.xrstrip(title, '\x00')[:128] or utils.xrstrip(title, '\x00')[:128].encode('utf-8')
 
111
        self.device_uri = UniStr(device_uri)
 
112
        self.printer_name = UniStr(printer_name)
108
113
        self.event_code = int(event_code)
109
 
        self.username = unicode(utils.xrstrip(username, '\x00'))[:32].encode('utf-8')
 
114
        self.username = UniStr(username)
110
115
        self.job_id = int(job_id)
111
 
        self.title = unicode(utils.xrstrip(title, '\x00'))[:128].encode('utf-8')
 
116
        self.title = UniStr(title)
112
117
 
113
118
        if timedate:
114
119
            self.timedate = float(timedate)
1299
1304
    def openEWS_LEDM(self):
1300
1305
        return self.__openChannel(hpmudext.HPMUD_S_EWS_LEDM_CHANNEL)
1301
1306
 
 
1307
    def openLEDM(self):
 
1308
        return self.__openChannel(hpmudext.HPMUD_S_LEDM_SCAN)
 
1309
 
 
1310
    def openMarvell_EWS(self):
 
1311
        return self.__openChannel(hpmudext.HPMUD_S_MARVELL_EWS_CHANNEL)
 
1312
 
1302
1313
    def closePrint(self):
1303
1314
        return self.__closeChannel(hpmudext.HPMUD_S_PRINT_CHANNEL)
1304
1315
 
1323
1334
    def closeEWS_LEDM(self):
1324
1335
        return self.__closeChannel(hpmudext.HPMUD_S_EWS_LEDM_CHANNEL)
1325
1336
 
 
1337
    def closeLEDM(self):
 
1338
        return self.__closeChannel(hpmudext.HPMUD_S_LEDM_SCAN)
 
1339
 
 
1340
    def closeMarvell_EWS(self):
 
1341
        return self.__closeChannel(hpmudext.HPMUD_S_MARVELL_EWS_CHANNEL)
 
1342
 
1326
1343
    def openCfgUpload(self):
1327
1344
        return self.__openChannel(hpmudext.HPMUD_S_CONFIG_UPLOAD_CHANNEL)
1328
1345
 
1703
1720
 
1704
1721
            elif status_type == STATUS_TYPE_LEDM:
1705
1722
                log.debug("Type 10: LEDM")
1706
 
                status_block = status.StatusType10(self)
 
1723
                status_block = status.StatusType10(self.getEWSUrl_LEDM)
 
1724
 
 
1725
            elif status_type == STATUS_TYPE_LEDM_FF_CC_0:
 
1726
                log.debug("Type 11: LEDM_FF_CC_0")
 
1727
                status_block = status.StatusType10(self.getUrl_LEDM)
1707
1728
 
1708
1729
            else:
1709
1730
                log.error("Unimplemented status type: %d" % status_type)
1805
1826
                                    'rr' : rr,
1806
1827
                                  })
1807
1828
 
 
1829
                #Check if device itself is sending the supplies info. If so, then in that case we need not check model.dat static data and
 
1830
                #compare with region, kind and type values.
 
1831
                dynamic_sku_data = False
 
1832
                for agent in agents:
 
1833
                    try:
 
1834
                        if agent['agent-sku'] != '':
 
1835
                            dynamic_sku_data = True
 
1836
                            break
 
1837
                    except:
 
1838
                        pass                                 
 
1839
 
1808
1840
                a, aa = 1, 1
1809
1841
                while True:
1810
 
                    mq_agent_kind = self.mq.get('r%d-agent%d-kind' % (r_value, a), -1)
1811
 
 
1812
 
                    if mq_agent_kind == -1:
1813
 
                        break
1814
 
 
1815
 
                    mq_agent_type = self.mq.get('r%d-agent%d-type' % (r_value, a), 0)
1816
 
                    mq_agent_sku = self.mq.get('r%d-agent%d-sku' % (r_value, a), '')
1817
 
 
1818
 
                    found = False
1819
 
 
1820
 
                    log.debug("Looking for kind=%d, type=%d..." % (mq_agent_kind, mq_agent_type))
1821
 
                    for agent in agents:
 
1842
                    if dynamic_sku_data:
 
1843
                        if a > len(agents):
 
1844
                            break 
 
1845
                        agent = agents[a-1]
 
1846
                        mq_agent_sku = agent['agent-sku']
1822
1847
                        agent_kind = agent['kind']
1823
1848
                        agent_type = agent['type']
1824
 
 
1825
 
                        if agent_kind == mq_agent_kind and \
1826
 
                           agent_type == mq_agent_type:
1827
 
                           found = True
1828
 
                           break
 
1849
                        found = True
 
1850
                    else:
 
1851
                        mq_agent_kind = self.mq.get('r%d-agent%d-kind' % (r_value, a), -1)
 
1852
                        if mq_agent_kind == -1:
 
1853
                            break
 
1854
                        mq_agent_type = self.mq.get('r%d-agent%d-type' % (r_value, a), 0)
 
1855
                        mq_agent_sku = self.mq.get('r%d-agent%d-sku' % (r_value, a), '')
 
1856
                        found = False
 
1857
 
 
1858
                        log.debug("Looking for kind=%d, type=%d..." % (mq_agent_kind, mq_agent_type))
 
1859
                        for agent in agents:
 
1860
                            agent_kind = agent['kind']
 
1861
                            agent_type = agent['type']
 
1862
 
 
1863
                            if agent_kind == mq_agent_kind and \
 
1864
                               agent_type == mq_agent_type:
 
1865
                                   found = True
 
1866
                                   break
1829
1867
 
1830
1868
                    if found:
1831
1869
                        log.debug("found: r%d-kind%d-type%d" % (r_value, agent_kind, agent_type))
1848
1886
                        # if agent health is OK, check for low supplies. If low, use
1849
1887
                        # the agent level trigger description for the agent description.
1850
1888
                        # Otherwise, report the agent health.
1851
 
                        if (status_code == STATUS_PRINTER_IDLE or status_code == STATUS_PRINTER_OUT_OF_INK) and \
 
1889
                        if (status_code == STATUS_PRINTER_POWER_SAVE or status_code == STATUS_PRINTER_IDLE or status_code == STATUS_PRINTER_OUT_OF_INK) and \
1852
1890
                            (agent_health == AGENT_HEALTH_OK or
1853
1891
                             (agent_health == AGENT_HEALTH_FAIR_MODERATE and agent_kind == AGENT_KIND_HEAD)) and \
1854
1892
                            agent_level_trigger >= AGENT_LEVEL_TRIGGER_MAY_BE_LOW:
2111
2149
    def readEWS_LEDM(self, bytes_to_read, stream=None, timeout=prop.read_timeout, allow_short_read=True):
2112
2150
        return self.__readChannel(self.openEWS_LEDM, bytes_to_read, stream, timeout, allow_short_read)
2113
2151
 
 
2152
    def readLEDM(self, bytes_to_read, stream=None, timeout=prop.read_timeout, allow_short_read=True):
 
2153
        return self.__readChannel(self.openLEDM, bytes_to_read, stream, timeout, allow_short_read)
 
2154
 
 
2155
    def readMarvell_EWS(self, bytes_to_read, stream=None, timeout=prop.read_timeout, allow_short_read=True):
 
2156
        return self.__readChannel(self.openMarvell_EWS, bytes_to_read, stream, timeout, allow_short_read)
 
2157
 
2114
2158
    def readSoapFax(self, bytes_to_read, stream=None, timeout=prop.read_timeout, allow_short_read=True):
2115
2159
        return self.__readChannel(self.openSoapFax, bytes_to_read, stream, timeout, allow_short_read)
2116
2160
 
2194
2238
    def writeEWS_LEDM(self, data):
2195
2239
        return self.__writeChannel(self.openEWS_LEDM, data)
2196
2240
 
 
2241
    def writeLEDM(self, data):
 
2242
        return self.__writeChannel(self.openLEDM, data)
 
2243
 
 
2244
    def writeMarvell_EWS(self, data):
 
2245
        return self.__writeChannel(self.openMarvell_EWS, data)
 
2246
 
2197
2247
    def writeCfgDownload(self, data):
2198
2248
        return self.__writeChannel(self.openCfgDownload, data)
2199
2249
 
2444
2494
        try:
2445
2495
            url2 = "%s&loc=%s" % (self.device_uri.replace('hpfax:', 'hp:'), url)
2446
2496
            data = self
 
2497
            opener = LocalOpenerEWS_LEDM({})
 
2498
            try:
 
2499
                if footer:
 
2500
                    return opener.open_hp(url2, data, footer)
 
2501
                else:
 
2502
                    return opener.open_hp(url2, data)
 
2503
            except Error:
 
2504
                log.debug("Status read failed: %s" % url2)
 
2505
        finally:
 
2506
            self.closeEWS_LEDM()
 
2507
 
 
2508
    def getUrl_LEDM(self, url, stream, footer=""):
 
2509
        try:
 
2510
            url2 = "%s&loc=%s" % (self.device_uri.replace('hpfax:', 'hp:'), url)
 
2511
            data = self
2447
2512
            opener = LocalOpener_LEDM({})
2448
2513
            try:
2449
2514
                if footer:
2450
2515
                    return opener.open_hp(url2, data, footer)
2451
2516
                else:
2452
 
                    return opener.open_hp(url2, data) 
 
2517
                    return opener.open_hp(url2, data)
2453
2518
            except Error:
2454
2519
                log.debug("Status read failed: %s" % url2)
2455
2520
 
2456
2521
        finally:
2457
 
            self.closeEWS_LEDM()
 
2522
            self.closeLEDM()
 
2523
 
 
2524
    def FetchLEDMUrl(self, url, footer=""):
 
2525
        data_fp = cStringIO.StringIO()
 
2526
        if footer:
 
2527
            data = self.getUrl_LEDM(url, data_fp, footer)
 
2528
        else:
 
2529
            data = self.getUrl_LEDM(url, data_fp)
 
2530
        if data:
 
2531
            data = data.split('\r\n\r\n', 1)[1]
 
2532
            if data:
 
2533
                data = status.clean(data)
 
2534
        return data
 
2535
 
 
2536
#-------------------------For LEDM SOAP PROTOCOL(FAX) Devices----------------------------------------------------------------------#
 
2537
 
 
2538
    def FetchEWS_LEDMUrl(self, url, footer=""):
 
2539
        data_fp = cStringIO.StringIO()
 
2540
        if footer:
 
2541
            data = self.getEWSUrl_LEDM(url, data_fp, footer)
 
2542
        else:
 
2543
            data = self.getEWSUrl_LEDM(url, data_fp)
 
2544
        if data:
 
2545
            data = data.split('\r\n\r\n', 1)[1]
 
2546
            if data:
 
2547
                data = status.clean(data)
 
2548
        return data
 
2549
 
 
2550
    def readAttributeFromXml_EWS(self, uri, attribute):
 
2551
        stream = cStringIO.StringIO()
 
2552
        data = self.FetchEWS_LEDMUrl(uri)
 
2553
        if not data:
 
2554
            log.error("Unable To read the XML data from device")
 
2555
            return ""
 
2556
        xmlDict = utils.XMLToDictParser().parseXML(data)
 
2557
        try:
 
2558
            #return str(xmlDict[attribute])
 
2559
            return xmlDict[attribute]
 
2560
        except:
 
2561
            return str("")
 
2562
 
 
2563
#---------------------------------------------------------------------------------------------------#
 
2564
 
2458
2565
    def readAttributeFromXml(self,uri,attribute):
2459
2566
        stream = cStringIO.StringIO()
2460
 
        data = status.StatusType10FetchUrl(self,uri)        
 
2567
        data = self.FetchLEDMUrl(uri)
2461
2568
        if not data:
2462
2569
            log.error("Unable To read the XML data from device")
2463
2570
            return ""
2464
 
        xmlDict = utils.XMLToDictParser().parseXML(data)  
2465
 
        return str(xmlDict[attribute])
2466
 
                
 
2571
        xmlDict = utils.XMLToDictParser().parseXML(data)
 
2572
        try:
 
2573
            return str(xmlDict[attribute])
 
2574
        except:
 
2575
            return str("")
 
2576
 
2467
2577
    def downloadFirmware(self, usb_bus_id=None, usb_device_id=None): # Note: IDs not currently used
2468
2578
        ok = False
2469
2579
        filename = os.path.join(prop.data_dir, "firmware", self.model.lower() + '.fw.gz')
2541
2651
            return response.fp
2542
2652
 
2543
2653
# URLs: hp:/usb/HP_OfficeJet_7500?serial=00XXXXXXXXXX&loc=/hp/device/info_device_status.xml
2544
 
class LocalOpener_LEDM(urllib.URLopener):
 
2654
class LocalOpenerEWS_LEDM(urllib.URLopener):
2545
2655
    def open_hp(self, url, dev, foot=""):
2546
2656
        log.debug("open_hp(%s)" % url)
2547
2657
 
2560
2670
 
2561
2671
        reply = xStringIO()
2562
2672
 
2563
 
        while dev.readEWS_LEDM(8080, reply, timeout=3):
2564
 
            pass
2565
 
 
2566
 
        reply.seek(0)
2567
 
        return reply.getvalue()
 
2673
        while dev.readEWS_LEDM(512, reply, timeout=3):
 
2674
            pass
 
2675
 
 
2676
        reply.seek(0)
 
2677
        return reply.getvalue()
 
2678
 
 
2679
# URLs: hp:/usb/HP_OfficeJet_7500?serial=00XXXXXXXXXX&loc=/hp/device/info_device_status.xml
 
2680
class LocalOpener_LEDM(urllib.URLopener):
 
2681
    def open_hp(self, url, dev, foot=""):
 
2682
        log.debug("open_hp(%s)" % url)
 
2683
 
 
2684
        match_obj = http_pat_url.search(url)
 
2685
        loc = url.split("=")[url.count("=")]
 
2686
 
 
2687
        dev.openLEDM()
 
2688
        if foot:
 
2689
            if "PUT" in foot:
 
2690
                dev.writeLEDM("""%s""" % foot)
 
2691
            else:
 
2692
                dev.writeLEDM("""POST %s HTTP/1.1\r\nContent-Type:text/xml\r\nContent-Length:%s\r\nAccept-Encoding: UTF-8\r\nHost:localhost\r\nUser-Agent:hplip\r\n\r\n """ % (loc, len(foot)))
 
2693
                dev.writeLEDM("""%s""" % foot)
 
2694
        else:
 
2695
            dev.writeLEDM("""GET %s HTTP/1.1\r\nAccept: text/plain\r\nHost:localhost\r\nUser-Agent:hplip\r\n\r\n""" % loc)
 
2696
 
 
2697
        reply = xStringIO()
 
2698
 
 
2699
        while dev.readLEDM(512, reply, timeout=3):
 
2700
            pass
 
2701
 
 
2702
        #TODO:Need to add following code in order to improve the delay.
 
2703
        #exp_end_of_data="0\r\n\r\n"
 
2704
        #num_of_bytes_read = dev.readEWS_LEDM(512, reply, timeout=5)
 
2705
 
 
2706
        #while num_of_bytes_read:
 
2707
            #temp_buf = xStringIO()
 
2708
            #num_of_bytes_read = dev.readEWS_LEDM(512, temp_buf, timeout=5)
 
2709
            #reply.write(temp_buf.getvalue())
 
2710
 
 
2711
            #if num_of_bytes_read == 5 and exp_end_of_data == temp_buf.getvalue():
 
2712
            #    break
 
2713
            #pass
 
2714
 
 
2715
        reply.seek(0)
 
2716
        return reply.getvalue()
 
2717
 
 
2718
 
 
2719