def _on_exception(self, request, e, original_on_exception): ex = ExceptionUtils.extract_exception(e, urllib2.HTTPError) if ex and ex.code >= 400 and ex.code <= 599 and ex.code != 503: request.tries = request.current_tries if original_on_exception and not (original_on_exception is self._on_exception): original_on_exception(request, e)
def get_drives(self, request_params=None, access_tokens=None): drives = [{ 'id' : self._user['permissionId'], 'name' : '', 'type' : '' }] try: all_teamdrives_fetch = False page_token = None parameters = {'pageSize': 100} while not all_teamdrives_fetch: if page_token: parameters['nextPageToken'] = page_token response = self.get('/teamdrives', parameters=parameters, request_params=request_params, access_tokens=access_tokens) if response and 'teamDrives' in response: for drive in response['teamDrives']: drives.append({ 'id' : drive['id'], 'name' : Utils.get_safe_value(drive, 'name', drive['id']), 'type' : drive['kind'] }) if response and 'nextPageToken' in response: page_token = response['nextPageToken'] else: all_teamdrives_fetch = True except RequestException as ex: httpex = ExceptionUtils.extract_exception(ex, HTTPError) if not httpex or httpex.code != 403: raise ex return drives
def do_GET(self): Logger.debug(self.path) data = self.path.split('/') code = 307 headers = {} content = Utils.get_file_buffer() if len(data) > 4 and data[1] == self.server.service.name: try: driveid = data[2] provider = self.server.data() account_manager = AccountManager( self.server.service.profile_path) provider.configure(account_manager, driveid) item = provider.get_item(item_driveid=data[3], item_id=data[4], include_download_info=True) headers['location'] = item['download_info']['url'] except Exception as e: httpex = ExceptionUtils.extract_exception(e, HTTPError) if httpex: code = httpex.code else: code = 500 ErrorReport.handle_exception(e) content.write(ExceptionUtils.full_stacktrace(e)) else: code = 404 self.write_response(code, content=content, headers=headers)
def do_POST(self): content = Utils.get_file_buffer() data = self.path.split('/') if len(data) > 1 and data[1] == self.server.service.name: try: size = int(self.headers.getheader('content-length', 0)) cmd = eval(self.rfile.read(size)) method = Utils.get_safe_value(cmd, 'method') if method: code = 200 args = Utils.get_safe_value(cmd, 'args', []) kwargs = Utils.get_safe_value(cmd, 'kwargs', {}) Logger.debug('Command received:\n%s' % cmd) content.write( repr(self.server.data.rpc(method, args, kwargs))) else: code = 400 content.write('Method required') except Exception as e: httpex = ExceptionUtils.extract_exception(e, HTTPError) if httpex: code = httpex.code else: code = 500 content.write(ExceptionUtils.full_stacktrace(e)) else: code = 404 self.write_response(code, content=content)
def do_GET(self): Logger.debug(self.path) data = self.path.split('/') code = 307 headers = {} content = Utils.get_file_buffer() if len(data) > 5 and data[1] == self.server.service.name: try: item = RpcUtil.rpc(data[2], 'get_item', kwargs = { 'driveid' : data[3], 'item_driveid' : data[4], 'item_id' : data[5], 'include_download_info' : True }) headers['location'] = item['download_info']['url'] except Exception as e: httpex = ExceptionUtils.extract_exception(e, HTTPError) if httpex: code = httpex.code else: code = 500 content.write(ExceptionUtils.full_stacktrace(e)) else: code = 404 self.write_response(code, content=content, headers=headers)
def get_drives(self, request_params=None, access_tokens=None): drives = [] drives_id_list = [] try: response = self.get('/drives', request_params=request_params, access_tokens=access_tokens) for drive in response['value']: drives_id_list.append(drive['id']) drives.append({ 'id': drive['id'], 'name': Utils.get_safe_value(drive, 'name', ''), 'type': drive['driveType'] }) except RequestException as ex: httpex = ExceptionUtils.extract_exception(ex, HTTPError) if not httpex or httpex.code != 403: raise ex response = self.get('/me/drives', request_params=request_params, access_tokens=access_tokens) for drive in response['value']: if not drive['id'] in drives_id_list: drives_id_list.append(drive['id']) drives.append({ 'id': drive['id'], 'name': Utils.get_safe_value(drive, 'name', ''), 'type': drive['driveType'] }) return drives
def do_GET(self): data = self.path.split('/') size = len(data) if size > 1 and data[1] == self.server.service.name: try: if size == 2: self.write_response(303, headers={'location': self.path + '/'}) elif size > 2 and data[2]: addon_name = data[2] if size == 3: self.write_response(303, headers={'location': self.path + '/'}) elif size == 4 and not data[3]: self.show_drives(addon_name) else: drive_name = data[3] path = self.path[len(self.server.service.name)+len(addon_name)+len(drive_name)+3:] self.process_path(addon_name, drive_name, path) else: self.show_addon_list() except Exception as e: httpex = ExceptionUtils.extract_exception(e, HTTPError) if httpex: response_code = httpex.code else: response_code = 500 content = Utils.get_file_buffer() content.write(ExceptionUtils.full_stacktrace(e)) self.write_response(response_code, content=content) else: self.write_response(404)
def handle_exception(ex): stacktrace = ExceptionUtils.full_stacktrace(ex) rex = ExceptionUtils.extract_exception(ex, RequestException) httpex = ExceptionUtils.extract_exception(ex, HTTPError) dnf = ExceptionUtils.extract_exception(ex, DriveNotFoundException) line1 = '' line2 = Utils.unicode(ex) send_report = True log_report = True if rex and rex.response: line1 = Utils.unicode(rex) line2 = ExceptionUtils.extract_error_message(rex.response) if httpex: if httpex.code == 401: send_report = False elif httpex.code == 404: send_report = False log_report = False if dnf: send_report = False log_report = False addonid = KodiUtils.get_addon_info('id') addon_version = KodiUtils.get_addon_info('version') common_addon_version = KodiUtils.get_addon_info( 'version', 'script.module.clouddrive.common') report = '[%s] [%s]/[%s]\n\n%s\n%s\n%s\n\n%s' % ( addonid, addon_version, common_addon_version, line1, line2, '', stacktrace) if rex: report += '\n\n%s\nResponse:\n%s' % (rex.request, rex.response) if log_report: Logger.debug(report) else: Logger.debug(ex) if send_report: Logger.notice(report) Logger.notice('Report sent') ErrorReport.send_report(report)
def rpc(self, method, args=None, kwargs=None): args = Utils.default(args, []) kwargs = Utils.default(kwargs, {}) method = getattr(self, method) fkwargs = {} for name in inspect.getargspec(method)[0]: if name in kwargs: fkwargs[name] = kwargs[name] try: return method(*args, **fkwargs) except Exception as ex: handle = True httpex = ExceptionUtils.extract_exception(ex, HTTPError) if httpex: handle = httpex.code != 404 if handle: self._handle_exception(ex, False) raise ex
def get_drives(self, request_params=None, access_tokens=None): drives = [{ 'id' : self._user['permissionId'], 'name' : '', 'type' : '' }] try: response = self.get('/teamdrives', request_params=request_params, access_tokens=access_tokens) if response and 'teamDrives' in response: for drive in response['teamDrives']: drives.append({ 'id' : drive['id'], 'name' : Utils.get_safe_value(drive, 'name', drive['id']), 'type' : drive['kind'] }) except RequestException as ex: httpex = ExceptionUtils.extract_exception(ex, HTTPError) if not httpex or httpex.code != 403: raise ex return drives
def _handle_exception(self, ex, show_error_dialog = True): stacktrace = ExceptionUtils.full_stacktrace(ex) rex = ExceptionUtils.extract_exception(ex, RequestException) uiex = ExceptionUtils.extract_exception(ex, UIException) httpex = ExceptionUtils.extract_exception(ex, HTTPError) urlex = ExceptionUtils.extract_exception(ex, URLError) line1 = self._common_addon.getLocalizedString(32027) line2 = Utils.unicode(ex) line3 = self._common_addon.getLocalizedString(32016) if uiex: line1 = self._common_addon.getLocalizedString(int(Utils.str(uiex))) line2 = Utils.unicode(uiex.root_exception) elif rex and rex.response: line1 += ' ' + Utils.unicode(rex) line2 = ExceptionUtils.extract_error_message(rex.response) send_report = True add_account_cmd = 'RunPlugin('+self._addon_url + '?' + urllib.urlencode({'action':'_add_account', 'content_type': self._content_type})+')' if isinstance(ex, AccountNotFoundException) or isinstance(ex, DriveNotFoundException): show_error_dialog = False if self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32063) % '\n'): KodiUtils.executebuiltin(add_account_cmd) elif rex and httpex: if httpex.code >= 500: line1 = self._common_addon.getLocalizedString(32035) line2 = None line3 = self._common_addon.getLocalizedString(32038) elif httpex.code >= 400: driveid = Utils.get_safe_value(self._addon_params, 'driveid') if driveid: self._account_manager.load() account = self._account_manager.get_account_by_driveid(driveid) drive = self._account_manager.get_drive_by_driveid(driveid) if KodiUtils.get_signin_server() in rex.request or httpex.code == 401: send_report = False show_error_dialog = False if self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32046) % (self._get_display_name(account, drive, True), '\n')): KodiUtils.executebuiltin(add_account_cmd) elif httpex.code == 403: line1 = self._common_addon.getLocalizedString(32019) line2 = line3 = None elif httpex.code == 404: send_report = False line1 = self._common_addon.getLocalizedString(32037) line2 = line2 = None else: line1 = self._common_addon.getLocalizedString(32036) line3 = self._common_addon.getLocalizedString(32038) else: if KodiUtils.get_signin_server()+'/pin/' in rex.request and httpex.code == 404 and self._ip_before_pin: ip_after_pin = Request(KodiUtils.get_signin_server() + '/ip', None).request() if self._ip_before_pin != ip_after_pin: send_report = False line1 = self._common_addon.getLocalizedString(32072) line2 = self._common_addon.getLocalizedString(32073) % (self._ip_before_pin, ip_after_pin,) elif urlex: reason = Utils.str(urlex.reason) line3 = self._common_addon.getLocalizedString(32074) if '[Errno 101]' in reason: line1 = self._common_addon.getLocalizedString(32076) elif '[Errno 11001]' in reason: line1 = self._common_addon.getLocalizedString(32077) elif 'CERTIFICATE_VERIFY_FAILED' in reason: line1 = self._common_addon.getLocalizedString(32078) else: line1 = self._common_addon.getLocalizedString(32075) report = '[%s] [%s]/[%s]\n\n%s\n%s\n%s\n\n%s' % (self._addonid, self._addon_version, self._common_addon_version, line1, line2, line3, stacktrace) if rex: report += '\n\n%s\nResponse:\n%s' % (rex.request, rex.response) report += '\n\nshow_error_dialog: %s' % show_error_dialog Logger.error(report) if show_error_dialog: self._dialog.ok(self._addon_name, line1, line2, line3) if send_report: report_error = KodiUtils.get_addon_setting('report_error', self._common_addon_id) == 'true' report_error_invite = KodiUtils.get_addon_setting('report_error_invite', self._common_addon_id) == 'true' if not report_error and not report_error_invite: if not self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32050), None, None, self._common_addon.getLocalizedString(32012), self._common_addon.getLocalizedString(32013)): KodiUtils.set_addon_setting('report_error', 'true', self._common_addon_id) KodiUtils.set_addon_setting('report_error_invite', 'true', self._common_addon_id) ErrorReport.send_report(report)
def do_GET(self): Logger.debug(self.path + ': Requested') if self._system_monitor.abortRequested(): Logger.debug(self.path + ': abort requested') return data = self.path.split('/') size = len(data) cached_page = self._page_cache.get(self.path) if cached_page: if cached_page['pending']: Logger.debug(self.path + ': Already requested. Waiting for original request...') max_waiting_time = time.time() + 30 while not self._system_monitor.abortRequested() and max_waiting_time > time.time() and cached_page['pending']: if self._system_monitor.waitForAbort(1): break cached_page = self._page_cache.get(self.path) if not self._system_monitor.abortRequested(): if cached_page['pending']: self.write_response(504) Logger.debug(self.path + ': 504 - Gateway timeout') self._page_cache.remove(self.path) else: if 'content' in cached_page and cached_page['content']: content = Utils.get_file_buffer() content.write(cached_page['content']) cached_page['content'] = content self.write_response(cached_page['response_code'], content=Utils.get_safe_value(cached_page, 'content'), headers=Utils.get_safe_value(cached_page, 'headers', {})) Logger.debug(self.path + ': %d - Served from cache' % cached_page['response_code']) else: cached_page = {'pending': True} self._page_cache.set(self.path, cached_page) if size > 1 and data[1] == self.server.service.name: try: if size == 2: cached_page['response_code'] = 303 cached_page['headers'] = {'location': self.path + '/'} elif size > 2 and data[2]: cached_page = self.handle_resource_request(data) else: cached_page = self.show_addon_list() except Exception as e: httpex = ExceptionUtils.extract_exception(e, HTTPError) if httpex: cached_page['response_code'] = httpex.code else: cached_page['response_code'] = 500 ErrorReport.handle_exception(e) content = Utils.get_file_buffer() content.write(ExceptionUtils.full_stacktrace(e)) cached_page['content'] = content else: cached_page['response_code'] = 404 cached_page['pending'] = False content_value = None if 'content' in cached_page: content_value = cached_page['content'].getvalue() self.write_response(cached_page['response_code'], content=Utils.get_safe_value(cached_page, 'content'), headers=Utils.get_safe_value(cached_page, 'headers', {})) cached_page['content'] = content_value if Utils.get_safe_value(cached_page, 'response_code', 0) >= 500: self._page_cache.remove(self.path) else: self._page_cache.set(self.path, cached_page) Logger.debug(self.path + ': Response code ' + Utils.str(cached_page['response_code']))
def on_exception(self, request, e): ex = ExceptionUtils.extract_exception(e, urllib2.HTTPError) if ex and ex.code == 404: self.persist_change_token(None)