class Downloader(QObject):
imageReady = Signal(QByteArray)
def __init__(self, parent=None):
super(Downloader, self).__init__(parent)
self.manager = QNetworkAccessManager()
self.url = 'http://localhost:9998/jpg/image.jpg'
self.request = QNetworkRequest()
self.request.setUrl(QUrl(self.url))
self.buffer = QByteArray()
self.reply = None
def setUrl(self, url):
self.url = url
self.request.setUrl(QUrl(self.url))
def downloadData(self):
""" Only request a new image if this is the first/last completed. """
if self.reply is None:
self.reply = self.manager.get(self.request)
self.reply.finished.connect(self.finished)
def finished(self):
""" Read the buffer, emit a signal with the new image in it. """
self.buffer = self.reply.readAll()
self.imageReady.emit(self.buffer)
self.reply.deleteLater()
self.reply = None
def request(self, method, endpoint, data=None, headers=None):
if not headers:
headers = {}
url = self.process_info.get('url')
token = self.process_info.get('token')
host = self.process_info.get('host')
if host in ('127.0.0.1', 'localhost'):
self.setNetworkAccessible(True)
req = QNetworkRequest(QUrl('%s/%s' % (url, endpoint)))
method = self.methods[str(method).lower()]
# assemble headers
if 'content-type' not in [x.lower() for x in headers.keys() if isinstance(x, str)]:
headers['content-type'] = 'text/plain'
headers['content-length'] = str(len(data if data else ''))
if token:
(name, value) = token.split(':')
headers[name] = value
for k, v in headers.items():
kb = k.encode('utf-8') # why?
vb = v.encode('utf-8')
req.setRawHeader(kb, vb)
if data is not None:
reply = method(req, data)
else:
reply = method(req)
reply.error.connect(lambda error, reply=reply, self=self: # pylint: disable=undefined-variable
self.handle_error(error, reply))
reply.finished.connect(lambda reply=reply, self=self: # pylint: disable=undefined-variable
self.print_reply(reply))
return reply
def __init__(self, parent=None):
super(Downloader, self).__init__(parent)
self.manager = QNetworkAccessManager()
self.url = 'http://localhost:9998/jpg/image.jpg'
self.request = QNetworkRequest()
self.request.setUrl(QUrl(self.url))
self.buffer = QByteArray()
self.reply = None
def download(self, url, path):
"""Download url and save data to path."""
# original_url = url
# print(url)
qurl = QUrl(url)
url = to_text_string(qurl.toEncoded(), encoding='utf-8')
logger.debug(str((url, path)))
if url in self._workers:
while not self._workers[url].finished:
return self._workers[url]
worker = DownloadWorker(url, path)
# Check download folder exists
folder = os.path.dirname(os.path.abspath(path))
if not os.path.isdir(folder):
os.makedirs(folder)
request = QNetworkRequest(qurl)
self._head_requests[url] = request
self._paths[url] = path
self._workers[url] = worker
self._manager.head(request)
self._timer.start()
return worker
def _request_finished(self, reply):
"""Callback for download once the request has finished."""
url = to_text_string(reply.url().toEncoded(), encoding='utf-8')
if url in self._paths:
path = self._paths[url]
if url in self._workers:
worker = self._workers[url]
if url in self._head_requests:
error = reply.error()
# print(url, error)
if error:
logger.error(str(('Head Reply Error:', error)))
worker.sig_download_finished.emit(url, path)
worker.sig_finished.emit(worker, path, error)
return
self._head_requests.pop(url)
start_download = not bool(error)
header_pairs = reply.rawHeaderPairs()
headers = {}
for hp in header_pairs:
headers[to_text_string(hp[0]).lower()] = to_text_string(hp[1])
total_size = int(headers.get('content-length', 0))
# Check if file exists
if os.path.isfile(path):
file_size = os.path.getsize(path)
# Check if existing file matches size of requested file
start_download = file_size != total_size
if start_download:
# File sizes dont match, hence download file
qurl = QUrl(url)
request = QNetworkRequest(qurl)
self._get_requests[url] = request
reply = self._manager.get(request)
error = reply.error()
if error:
logger.error(str(('Reply Error:', error)))
reply.downloadProgress.connect(
lambda r, t, w=worker: self._progress(r, t, w))
else:
# File sizes match, dont download file or error?
worker.finished = True
worker.sig_download_finished.emit(url, path)
worker.sig_finished.emit(worker, path, None)
elif url in self._get_requests:
data = reply.readAll()
self._save(url, path, data)
def get_stderr(self, last_nbytes):
self.stderr_collected = False
url = self.process_info.get('url')
host = self.process_info.get('host') # could get from url
# issues/412 circumvent network check if job is local
if host in ('127.0.0.1', 'localhost'):
self.setNetworkAccessible(True)
request = QNetworkRequest(QUrl(url + '/stderr/%s'%last_nbytes))
reply = self.methods['get'](request) # ugh
reply.error.connect(lambda error, reply=reply, self=self: # pylint: disable=undefined-variable
self.get_stderr_error(error, reply))
reply.finished.connect(lambda reply=reply, self=self: # pylint: disable=undefined-variable
self.get_stderr_finished(reply))
def get_status(self):
url = self.process_info.get('url')
host = self.process_info.get('host') # could get from url
if not url:
errmsg = 'cannot connect, no URL found for mfix process'
self.error(errmsg)
self.parent.status = {'error': errmsg}
#self.get_status_error()
self.parent.parent.parent.slot_update_status()
# issues/412 circumvent network check if job is local
if host in ('127.0.0.1', 'localhost'):
self.setNetworkAccessible(True)
request = QNetworkRequest(QUrl(url + '/status'))
reply = self.methods['get'](request) # ugh
reply.error.connect(lambda error, reply=reply, self=self: self.get_status_error(error, reply)) # pylint: disable=undefined-variable
reply.finished.connect(lambda reply=reply, self=self: self.get_status_finished(reply)) # pylint: disable=undefined-variable
def loadTile(self, x, y, zoom, url):
if self._manager is None:
self._manager = QNetworkAccessManager(parent=self)
self._manager.finished.connect(self.handleNetworkData)
cache = QNetworkDiskCache()
cacheDir = getCacheFolder()
cache.setCacheDirectory(cacheDir)
cache.setMaximumCacheSize(self._cacheSize)
self._manager.setCache(cache)
key = (x, y, zoom)
url = QUrl(url)
if key not in self._tileInDownload:
# Request the image to the map service
request = QNetworkRequest(url=url)
request.setRawHeader(b'User-Agent', self._userAgent)
request.setAttribute(QNetworkRequest.User, key)
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.PreferCache)
self._tileInDownload[key] = self._manager.get(request)
def loadTile(self, x, y, zoom, url, cache_dir):
if self._manager is None:
self._manager = QNetworkAccessManager(parent=self)
self._manager.finished.connect(self.handleNetworkData)
self._cache = './tiles'
key = (x, y, zoom)
url = QUrl(url)
#base = parsed_url.netloc
if key not in self._tileInDownload:
path = os.path.join(self._cache, str(cache_dir), str(zoom), str(x),
str(y) + '.png')
if os.path.exists(path):
self.tileLoaded.emit(x, y, zoom, open(path, 'rb').read())
else:
# Request the image to the map service
request = QNetworkRequest(url=url)
request.setRawHeader(b'User-Agent', self._userAgent)
request.setAttribute(QNetworkRequest.User, [key, cache_dir])
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.PreferCache)
self._tileInDownload[key] = self._manager.get(request)
def loadTile(self, x, y, zoom, url):
if self._manager is None:
self._manager = QNetworkAccessManager(parent=self)
self._manager.finished.connect(self.handleNetworkData)
cache = QNetworkDiskCache()
cacheDir = getCacheFolder()
cache.setCacheDirectory(cacheDir)
cache.setMaximumCacheSize(self._cacheSize)
self._manager.setCache(cache)
key = (x, y, zoom)
url = QUrl(url)
if key not in self._tileInDownload:
# Request the image to the map service
request = QNetworkRequest(url=url)
request.setRawHeader(b'User-Agent', self._userAgent)
request.setAttribute(QNetworkRequest.User, key)
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.PreferCache)
self._tileInDownload[key] = self._manager.get(request)