def __init__(self, message=None, *args, **kwargs): self.message = message or self.message Fault.__init__(self, self.code, self.message)
def __init__(self, message="", code=1000, *args, **kwargs): MyClipsServerException.__init__(self, message=message, *args, **kwargs) Fault.__init__(self, code, "[%s] %s"%(self.__class__.__name__, message), **kwargs)
def __init__(self): Fault.__init__(self, PERMISSION_DENIED_CODE, _('Permission denied'))
def __init__(self, message, code = 0, *args, **kwargs): Fault.__init__(self, code, message, *args, **kwargs)
def __init__(self, method_name): Fault.__init__(self, RPCFault.ACCESS_DENIED, method_name)
def __init__(self): Fault.__init__(self, PERMISSION_DENIED_CODE, _('Resource not found'))
def __init__(self, message): Fault.__init__(self, SADError.CORRUPTEDFILE, message)
def __init__(self, code, message, **extra): Fault.__init__(self, code, message, **extra) for key in extra: setattr(self, key, extra[key])
def __init__(self, value): Fault.__init__(self, XendClient.ERROR_INVALID_DOMAIN, value)
def __init__(self,message="Cound not handle the query"): Fault.__init__(self, UNHANDLED, message)
# next we check if the source URL does indeed exist if not g_blog.allow_pingback: raise Fault(49,"Access denied.") try: g_blog.tigger_action("pre_ping",source_uri,target_uri) response = urlfetch.fetch(source_uri) except Exception ,e : #logging.info(e.message) raise Fault(16, 'The source URL does not exist.%s'%source_uri) # we only accept pingbacks for links below our blog URL blog_url = g_blog.baseurl if not blog_url.endswith('/'): blog_url += '/' if not target_uri.startswith(blog_url): raise Fault(32, 'The specified target URL does not exist.') path_info = target_uri[len(blog_url):] pingback_post(response,source_uri,target_uri,path_info) try: return "Micolog pingback succeed!" except: raise Fault(49,"Access denied.") def get_excerpt(response, url_hint, body_limit=1024 * 512): """Get an excerpt from the given `response`. `url_hint` is the URL which will be used as anchor for the excerpt. The return value is a tuple in the form ``(title, body)``. If one of the two items could not be calculated it will be `None`.
def pingback(request, source, target): logger = tools.get_logger() logger.info("pingback started") source_file = urllib.urlopen(source.split('#')[0]) if source_file.headers.get('error', '') == '404': raise Fault(0x0010, "Target %s not exists" % target) source_page = parser() source_page.feed(source_file.read()) source_file.close() if source_page.title == "": source_page.title = source if not target in source_page.hrefs: raise Fault(0x0011, "%s does not point to %s" % (source, target)) target_entry = fileFor(request, target) body = '' try: from rssfinder import getFeeds from rssparser import parse baseurl = source.split("#")[0] for feed in getFeeds(baseurl): for item in parse(feed)['items']: if item['link'] == source: if 'title' in item: source_page.title = item['title'] if 'content_encoded' in item: body = item['content_encoded'].strip() if 'description' in item: body = item['description'].strip() or body body = re.compile('<.*?>', re.S).sub('', body) body = re.sub('\s+', ' ', body) body = body[:body.rfind(' ', 0, 250)][:250] + " ...<br />" except: pass cmt = {'title': source_page.title, 'author': 'Pingback from %s' % source_page.title, 'pubDate': str(time.time()), 'link': source, 'source': '', 'description': body} # run anti-spam plugins argdict = {"request": request, "comment": cmt} reject = tools.run_callback("trackback_reject", argdict, donefunc=lambda x: x != 0) if isinstance(reject, (tuple, list)) and len(reject) == 2: reject_code, reject_message = reject else: reject_code, reject_message = reject, "Pingback rejected." if reject_code == 1: raise Fault(0x0031, reject_message) from comments import writeComment config = request.get_configuration() data = request.get_data() data['entry_list'] = [target_entry] # TODO: Check if comment from the URL exists writeComment(request, config, data, cmt, config['blog_encoding']) return "success pinging %s from %s\n" % (target, source)
if context.opts.get('KojiDebug'): if tb_type == "extended": faultString = koji.format_exc_plus() else: faultString = tb_str else: faultString = str(e) else: if tb_type == "normal": faultString = tb_str elif tb_type == "extended": faultString = koji.format_exc_plus() else: faultString = "%s: %s" % (e_class, e) self.logger.warning(tb_str) response = dumps(Fault(faultCode, faultString)) return response def handle_upload(self, environ): #uploads can't be in a multicall context.method = None self.check_session() self.enforce_lockout() return kojihub.handle_upload(environ) def handle_rpc(self, environ): params, method = self._read_request(environ['wsgi.input']) return self._dispatch(method, params) def check_session(self):
def xmlrpc_return_fault(): return Fault(666, "Fault description")
def __init__(self, msg='Could not handle the exception'): Fault.__init__(self, UNHANDLED, msg)
def __init__(self, value): Fault.__init__(self, XendClient.ERROR_GENERIC, value) self.value = value
def __init__(self,message="Could not handle the query"): Fault.__init__(self,message="Access denied"):
def s3_upload(hashkey, size=ORIGINAL_SIZE): """ Upload a screenshot PNG file to Amazon S3. This uses httplib directly and transfers the file in small chunks, so we don't have to load the whole PNG file into RAM. """ from shotserver04.screenshots import s3 aws = s3.AWSAuthConnection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY, is_secure=False) s3_bucket = settings.S3_BUCKETS[str(size)] s3_key = hashkey + '.png' server = s3.DEFAULT_HOST method = 'PUT' path = '/%s/%s' % (s3_bucket, urllib.quote_plus(s3_key)) filename = png_filename(hashkey, size) f = file(filename, 'rb') f.seek(0, 2) # os.SEEK_END for Python < 2.5 bytes_total = f.tell() f.seek(0, 0) # os.SEEK_SET for Python < 2.5 headers = { 'User-Agent': 'shotserver/0.4', 'Host': server, 'x-amz-acl': 'public-read', 'Content-Type': 'image/png', 'Content-Length': str(bytes_total), } query_args = {} aws._add_aws_auth_header(headers, method, s3_bucket, s3_key, query_args) host = '%s:%d' % (server, 80) conn = httplib.HTTPConnection(host) conn.putrequest(method, path) for header_key, header_value in headers.iteritems(): conn.putheader(header_key, header_value) conn.endheaders() bytes_sent = 0 while True: bytes = f.read(BUFFER_SIZE) if not bytes: break conn.send(bytes) bytes_sent += len(bytes) # print 'sent', bytes_sent, 'of', bytes_total, 'bytes', # print '(%.1f%%)' % (100.0 * bytes_sent / bytes_total) assert bytes_sent == bytes_total f.close() response = conn.getresponse() if response.status != 200: raise Fault(response.status, response.read()) # print 'http://%s/%s' % (s3_bucket, s3_key) # Write response from S3 to tempfile for debugging if DEBUG_HEADERS and str(size) == '160': tempfile = file('/tmp/%s.txt' % hashkey, 'w') tempfile.write('==== Request headers ====\n') tempfile.write('%s %s HTTP/1.1\n' % (method, path)) for header, value in headers.iteritems(): tempfile.write('%s: %s\n' % (header, value)) tempfile.write('\n') tempfile.write('==== Response headers ====\n') tempfile.write('HTTP/1.1 %s %s\n' % (response.status, response.reason)) for header, value in response.getheaders(): tempfile.write('%s: %s\n' % (header, value)) tempfile.write('\n') tempfile.write(response.read()) # tempfile.write(response.msg) tempfile.close() conn.close()
def __init__(self, message): Fault.__init__(self, SADError.EMPTYSTREAM, message)
def test_returning_Fault(self): return Fault(1, 'custom Fault response')
def shutdown(self): if self._restartable: self._shutdown = True return from supervisor import xmlrpc raise Fault(xmlrpc.Faults.SHUTDOWN_STATE, '')
def __init__(self): Fault.__init__(self, PERMISSION_DENIED_CODE, _("Permission denied"))
def readLog(self, whence, offset): if self._readlog_error: raise Fault(self._readlog_error, '') return 'mainlogdata'
def __init__(self, message): Fault.__init__(self, RPCFault.NOT_FOUND, message)
def fault(): raise Fault(123, "ERROR")
def __init__(self, message = "Finish list all access files!"): Fault.__init__(self, FINISH_LIST_FILES, message)
def on_error(*args, **kwargs): body = str(sys.exc_info()[1]) from xmlrpclib import Fault, dumps _set_response(dumps(Fault(1, body)))
def custom_commands_main(argv): """custom commands.main that handle errors using XMLError""" import bzrlib.ui bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal( sys.stdin, sys.stdout, sys.stderr) try: _argv = [] for a in argv[1:]: if isinstance(a, str): a = a.decode(bzrlib.osutils.get_user_encoding()) _argv.append(a) argv = _argv ret = commands.run_bzr(argv) return ret except errors.BzrError, e: raise Fault(42, str(XMLError(e))) except Exception, e: traceback.print_exc(file=sys.__stderr__) raise Fault(32, str(XMLError(e))) def register_functions(server): """register functions exposed via xmlrpc.""" server.register_function(run_bzr, 'run_bzr_command') server.register_function(run_bzr_xml, 'run_bzr') import search if search.is_available: server.register_function(search.search, 'search')
def clearProcessStdoutLog(self, name): from xmlrpclib import Fault from supervisor import xmlrpc if name == 'BAD_NAME': raise Fault(xmlrpc.Faults.BAD_NAME, 'BAD_NAME') return True
def readLog(self, whence, offset): if self._readlog_error: from xmlrpclib import Fault raise Fault(self._readlog_error, '') return 'mainlogdata'
def __init__(self, msg='Access denied'): Fault.__init__(self, ACCESS_DENIED, msg)
def __init__(self,ACCESS_DENIED,message): Fault.__init__(self,ACCESS_DENIED,message)
def __init__(self, value): Fault.__init__(self, ERROR_GENERIC, value) self.value = value
def __init__(self, errorcode=UNHANDLED, message="Interrupt when handling the query"): Fault.__init__(self, errorcode, message)
def __init__(self,message): Fault.__init__(self, SADError.FILENOTFOUND, message)
def createFault(error, message): error_code = INVERSE_FAULT_CODES[error] return Fault(error_code, message)
def __init__(self, message): Fault.__init__(self, SADError.CLIENTDISCONNECTED, message)
def getVersion(): raise Fault(Faults.UNKNOWN_METHOD, 'duh')
def __init__(self, message): Fault.__init__(self, SADError.CONNECTIONERROR, message)
def getPages(cls, *args): """Returns a user-friendly error message.""" raise Fault(501, 'Sorry, pages are not supported at this time.')
def _some_nonexisting_method(): """A non-existing method raising Fault""" raise Fault(0, 'Testing')
def __init__(self): Fault.__init__(self, AUTHENTICATION_FAILED_CODE, _("Username and/or password is incorrect"))
def decode_fault(e, encoding='UTF-8'): assert isinstance(e, Fault) if isinstance(e.faultString, bytes): return Fault(e.faultCode, e.faultString.decode(encoding)) return e
def __init__(self, method_name): Fault.__init__(self, RPCFault.UNKNOWN_METHOD, method_name)
def __init__(self, message="Couldn't handle the query"): Fault.__init__(self, UNHANDlED, message)
def __init__(self, message): Fault.__init__(self, RPCFault.NOT_POSSIBLE, message)
def __init__(self, message="Access denied"): Fault.__init__(self, ACCESS_DENIED, message)
def __init__(self, method_name): Fault.__init__(self, RPCFault.INVALID_PARAMS, method_name)
def test_non_auth_fault(self): return self.verify_auth_error(Fault("blah", "some random error"))
def __init__(self, message = "Couldn't handle the query"): Fault.__init__(self, UNHANDLED, message)
def __init__(self, message="Build Error."): Fault.__init__(self, 10, message)
def __init__(self, message = "Access denied"): Fault.__init__(self, ACCESS_DENIED, message)
def __init__(self): Fault.__init__(self, AUTHENTICATION_FAILED_CODE, _('Username and/or password is incorrect'))