SlicerLabkeyExtension/labkeySlicerPythonExtension/slicerNetwork.py

import qt
import urllib2
import ssl
import cookielib
import xml.etree.ElementTree as ET
import re
import StringIO
import slicer
import shutil
import distutils
import os
import base64

class slicerNetwork:
    def __init__(self,parent):
        parent.title = "slicerNetwork"
        self.parent=parent

class labkeyURIHandler(slicer.vtkURIHandler):
    def __init__(self):
        slicer.vtkURIHandler.__init__(self)
        self.className="labkeyURIHandler"
        slicer.mrmlScene.AddURIHandler(self)
        try:
	       self.localCacheDirectory=os.path.join(os.environ["HOME"],"labkeyCache")
        except:
	    #in windows, the variable is called HOMEPATH
	       fhome=os.environ['HOMEDRIVE']+os.environ['HOMEPATH']
	       self.localCacheDirectory=os.path.join(fhome,"labkeyCache")

    def CanHandleURI(self,uri):
        print "labkeyURIHandler::CanHandleURI({0})".format(uri)
        if uri.find('labkey://')==0:
            return 1
        return 0

    def GetClassName(self):
        return self.className

    def GetHostName(self):
        return self.hostname

    def SetHostName(self,host):
        self.hostname=host

    def SetLocalCahceDirectory(self,dir):
        self.localCacheDirectory=dir

    def GetLocalCacheDirectory(self):
        return self.localCacheDirectory

    def GetLocalPath(self,source):
        relativePath=re.sub('labkey://','',source)
        sp=os.sep.encode('string-escape')
        print "Substituting / with {0} in {1}".format(sp,relativePath)
        relativePath=re.sub('/',sp,relativePath)
        return os.path.join(self.localCacheDirectory,relativePath)

    def GetFile(self,source):
        # check for file in cache. If available, use, if not, download
        localPath=self.GetLocalPath(source)
        if os.path.isfile(localPath):
            return localPath
        self.StageFileRead(source,localPath)
        return localPath

    def StageFileRead(self,source,dest):
        print "labkeyURIHandler::StageFileRead({0},{1})".format(source,dest)
        labkeyPath=re.sub('labkey://','',source)
        remote=self.readFile(self.hostname,labkeyPath)
        #make all necessary directories
        path=os.path.dirname(dest)
        try:
            os.makedirs(path)
        except:
            if not os.path.isdir(path):
                raise
        local=open(dest,'wb')
        #make sure we are at the begining of the file

	#check file size
	remote.seek(0,2)
	sz=remote.tell()
	print "Remote size: {0}".format(sz)

	remote.seek(0)
        shutil.copyfileobj(remote,local)
	print "Local size: {0}".format(local.tell())
        local.close()

    def StageFileWrite(self,source,dest):
        print "labkeyURIHandler::StageFileWrite({0},{1}) not implemented yet".format(
            source,dest)

    def fileTypesAvailable(self):
        return ('VolumeFile','SegmentationFile','TransformFile')

    #mimic slicer.util.loadNodeFromFile
    def loadNodeFromFile(self, filename, filetype, properties={}, returnNode=False):
        #this is the only relevant part - file must be downloaded to cache
        localPath=self.GetFile(filename)
        slicer.util.loadNodeFromFile(localPath,filetype,properties,returnNode)
        #remove retrieved file
        try:
            if not(properties['keepCachedFile']) :
                os.remove(localPath)
        except:
            pass


    def loadVolume(self,filename, properties={}, returnNode=False):
        filetype = 'VolumeFile'
        #redirect to self.loadNodeFromFile first to get the cached file
        return self.loadNodeFromFile(filename,filetype, properties,returnNode)

    def loadSegmentation(self,filename,properties={},returnNode=False):
        filetype='SegmentationFile'
        #redirect to self.loadNodeFromFile first to get the cached file
        return self.loadNodeFromFile(filename,filetype, properties,returnNode)
    #add others if needed


    def configureSSL(self,cert,key,pwd,cacert):
        #do this first
        try:
            self.ctx=ssl.SSLContext(ssl.PROTOCOL_SSLv23)
            self.ctx.load_cert_chain(cert,key,pwd)
            self.ctx.verify_mode=ssl.CERT_REQUIRED
            self.ctx.load_verify_locations(cacert)
        except ssl.SSLError as err:
            print " Failed to configure SSL: {0}".format(str(err))



    def connectRemote(self,serverUrl,uname,pwd):
        https_handler=urllib2.HTTPSHandler(context=self.ctx)
        self.SetHostName(serverUrl)
        #cookie part
        cj=cookielib.CookieJar()
        cookie_handler=urllib2.HTTPCookieProcessor(cj)
        self.opener=urllib2.build_opener(https_handler,cookie_handler)
        loginUrl=serverUrl+"/labkey/login/login.post"
        r=urllib2.Request(str(loginUrl))
        print "Connecting to {0}".format(loginUrl)
        r.add_header('ContentType','application/x-www-form-urlencoded')
        data="email="+uname+"&password="+pwd
        #print "Data: '{0}".format(data)
        r.add_data(data)

        self.opener.open(r)

    def initRemote(self):
        https_handler=urllib2.HTTPSHandler(context=self.ctx)
        #cookie part
        cj=cookielib.CookieJar()
        cookie_handler=urllib2.HTTPCookieProcessor(cj)
        self.opener=urllib2.build_opener(https_handler,cookie_handler)

    #cj in opener contains the cookies

    def get(self,url):

        print "GET: {0}".format(url)
        r=urllib2.Request(url)
        base64string = base64.b64encode('%s:%s' % (self.auth_name, self.auth_pass))
        r.add_header("Authorization", "Basic %s" % base64string)
        return self.opener.open(r)
        #f contains json as a return value

    def post(self,url,data):

        r=urllib2.Request(url)
        #makes it a post
        r.add_data(data)
        r.add_header("content-type","application/json")
        base64string = base64.b64encode('%s:%s' % (self.auth_name, self.auth_pass))
        r.add_header("Authorization", "Basic %s" % base64string)

        f=self.opener.open(r)
        #f contains json as a return value

    def listDir(self,dir):
        print "Listing for {0}".format(dir)
        dirUrl=self.hostname+"/labkey/_webdav"+"/"+dir
        r=propfindRequest(dirUrl)
        PROPFIND=u"""<?xml version="1.0" encoding="utf-8"?>\n
                    <propfind xmlns="DAV:">\n
                    <prop>\n
                    <getetag/>\n
                    </prop>\n
                    </propfind>"""
        r.add_header('content-type','text/xml; charset="utf-8"')
        r.add_header('content-length',str(len(PROPFIND)))
        r.add_header('Depth','1')
        r.add_data(PROPFIND)
        base64string = base64.b64encode('%s:%s' % (self.auth_name, self.auth_pass))
        r.add_header("Authorization", "Basic %s" % base64string)
        print "PROPFIND: {0}".format(dirUrl)
        dirs=[]
        try:
            f=self.opener.open(r)
        except:
            print "No data"
            return dirs
        tree=ET.XML(f.read())
        rps=tree.findall('{DAV:}response')
        for r in rps:
            hr=r.find('{DAV:}href')
            dirent=hr.text
            dirent=re.sub('/labkey/_webdav/','',dirent)
            dirs.append(dirent)
        del dirs[0]
        return dirs

    def toRelativePath(self,dirs):
        flist1=[]
        for d in dirs:
            if d[-1]=='/':
                d=d[:-1]
            if d.rfind('/')>-1:
                d=d[d.rfind('/')+1:]
            flist1.append(d)
        return flist1

    def readFile(self, serverUrl, path):
        dirUrl=serverUrl+"/labkey/_webdav"+"/"+path
        f=self.get(dirUrl)
        return StringIO.StringIO(f.read())

    def loadDir(self, path):
        #dirURL=serverUrl+"/labkey/_webdav/"+path
        files=self.listDir(path)
        fdir="NONE"
        for f in files:
            #returns local path
            try:
                fdir=os.path.dirname(self.GetFile(f))
            except:
                #fails if there is a subdirectory; go recursively
                self.readDir(f)
        return fdir

class propfindRequest(urllib2.Request):
    """
    This request subclass allows explicit specification of
    the HTTP request method. Basic urllib2.Request class
    chooses GET or POST depending on self.has_data()
    """
    def __init__(self, *args, **kwargs):
        #self.method = 'Propfind'
        urllib2.Request.__init__(self, *args, **kwargs)

    def get_method(self):
        return 'PROPFIND'