uriopener.py

XOT: XBMC Online TV Framework

import config
import os, sys, urllib2, cookielib, re, threading, socket, time
import xbmcgui
#import urllib

#===============================================================================
# Import logger
#===============================================================================
logFile = sys.modules['__main__'].globalLogFile

#===============================================================================
class UriHandler:
    def __init__(self):
        # set socket timeout in seconds
        #self.socketTimeOut = 5.0
        #socket.setdefaulttimeout(self.socketTimeOut)
        #logFile.debug("socket-Timeout: %s", socket.getdefaulttimeout())
        
        self.cj = cookielib.CookieJar()
        self.uriOpener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
        
        # change the user agent (thanks to VincePirez @ xbmc forums)
        self.user_agent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6 Alexa Toolbar"
        self.uriOpener.addheaders = [('User-Agent', self.user_agent)]
        
        self.defaultLocation = config.cacheDir
        self.pbAnimation = ["-","\\","|","/"]
        self.blockSize = (1024/4)#*8
        self.bytesToMB = 1048576
        self.inValidCharacters = "[^a-zA-Z0-9!#$%&'()-.@\[\]^_`{}]"
        logFile.info("UriHandler initialised")
        self.timerTimeOut = 2.0                     # used for the emergency canceler
        
        self.webTimeOutInterval = config.webTimeOut # max duration of request
        self.pollInterval = 0.1                     # time between polling of activity
                
    #===============================================================================
    def Download(self, uri, filename, folder="", pb=True ,params=""):    
        # assign things (PERHAPS CHECK FIRST IF NOT ASSIGNED)
        
        pbEnabled = pb
        pbTitle = ""
        pbLine1 = ""
        pbLine2 = ""
        if pbEnabled:
            uriPB = xbmcgui.DialogProgress()
        
        cancelled = False
        
        destFilename = self.CorrectFileName(filename)
        destFolder = folder
        
        blockMultiplier = 16*8 #to increase blockSize
                    
        # if no destination is given, get one via a dialog box
        if destFolder=="":
            dialog = xbmcgui.Dialog()
            destFolder = dialog.browse(3, 'Select download destination', 'files', '', False, False, self.defaultLocation)
        
        destComplete = os.path.join(destFolder, destFilename)    
                
        logFile.info('Creating Downloader for url: %s. And filename %s.', uri, destComplete)
        try:
            #create progress dialog
            if pbEnabled:
                pbTitle = 'Downloading the requested url'
                pbLine1 = uri
                uriPB.create(pbTitle, pbLine1)
            if params == "":
                sourceHandle = self.uriOpener.open(uri)
            else:
                sourceHandle = self.uriOpener.open(uri, params)                
            destHandle = open(destComplete, 'wb')
            headers = sourceHandle.info()
        
            fileSize = -1
            read = 0
            blocknum = 0
            
            if "content-length" in headers:
                fileSize = int(headers["Content-Length"])
                
            while 1:
                block = sourceHandle.read(self.blockSize*blockMultiplier)
                if block == "":
                    break
                read += len(block)
                destHandle.write(block)
                blocknum += 1
                
                if pbEnabled:
                    cancelled = self.PBHandler(blocknum, self.blockSize*blockMultiplier, fileSize, uriPB, pbLine1, pbLine2)
                    #check to see if cancelled
                    if cancelled:
                        break

            # clean up things
            sourceHandle.close()
            destHandle.close()
            
            if pbEnabled:
                uriPB.close()
            
            # delete parts if cancelled
            if cancelled:
                if os.path.exists(destComplete):
                    os.remove(destComplete)
                logFile.info("Download Cancelled")
                rtrn = ""
            else:
                logFile.info("Url %s downloaded succesfully.", uri)
                rtrn = destComplete
                
            return rtrn
            
        except:
            logFile.critical("Error caching file",exc_info=True)
            if os.path.exists(destComplete):
                os.remove(destComplete)
            if pbEnabled:
                uriPB.close()
            
            try:
                sourceHandle.close()
            except UnboundLocalError:
                pass
            try:
                destHandle.close()
            except UnboundLocalError:
                pass
            
            return ""

    #===============================================================================
    def Open(self, uri, pb=True, params=""):
        """
        Open an URL Async using a thread
        """
        try:
            
            progressbarEnabled = pb
            parameters = params
            targetUrl = uri
            pbTitle = ''
            pbLine1 = ''
            pbLine2 = ''
            blocks = 0
            filesize = 0
            canceled = False
            timeOut = False
            
            logFile.info("Opening requested uri Async: %s (already %s threads)", targetUrl, threading.activeCount())
                    
            if progressbarEnabled:
                pbTitle = 'Opening request url'
                pbLine1 = targetUrl
                uriPB = xbmcgui.DialogProgress()
                uriPB.create(pbTitle, pbLine1)
                
            openThread = AsyncOpener(targetUrl, self.uriOpener, self.blockSize, action='open',  params=parameters)
            openThread.start()
            #time.sleep(0.1)
            
            count = 0
            while not openThread.isCompleted and not canceled:
                if progressbarEnabled:
                    blocks = openThread.blocksRead
                    filesize = openThread.fileSize
                    #logFile.debug("%s van %s", blocks, filesize)
                    canceled = self.PBHandler(blocks, self.blockSize, filesize, uriPB, pbLine1, pbLine2)                          
                
                count += 1
                openThread.join(self.pollInterval)
                
                if self.pollInterval * count > self.webTimeOutInterval:
                    timeOut = True
                    break                
            
            # we are finished now
            if progressbarEnabled:
                uriPB.update(100, pbLine1 ,pbLine2)
                uriPB.close()
            
            if canceled:                
                logFile.warning("Opening of %s was cancelled", targetUrl)
                data = ""
            if timeOut:
                logFile.critical("The URL lookup did not respond within the TimeOut (%s s)", self.webTimeOutInterval)
                data = ""
            else:
                logFile.info("Url %s was opened successfully", targetUrl)                            
                data = openThread.data
            return data
        except:
            if progressbarEnabled:
                uriPB.close()
            
            logFile.debug("Error in threading", exc_info=True)
            return ""
        
    #===============================================================================
    def OpenSeq(self, uri, pb=True, params=""):
        raise DeprecationWarning() 
        # assign things (PERHAPS CHECK FIRST IF NOT ASSIGNED)
        pbEnabled = pb
        pbTitle = ""
        pbLine1 = ""
        pbLine2 = ""
        if pbEnabled:
            uriPB = xbmcgui.DialogProgress()
            #enable the timer for emergency canceling. Checks every 2 seconds
            self.PBEmergencyCanceler(pb=uriPB)
        
        cancelled = False
        
        try:
            logFile.info("Opening requested uri: %s", uri)
            #logFile.debug("Number of open threads %s", threading.activeCount())
            if pbEnabled:
                pbTitle = 'Opening request url'
                pbLine1 = uri
                uriPB.create(pbTitle, pbLine1)