Python ServerProxy.__getattr__方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
def handler(request):
    TIME = 't'
    CTIME = 'c'
    if request.method.upper() != METHOD.upper():
        return HTTP_NOT_IMPLEMENTED
    doc = request.read()
    db = lock = None
    response = OK
    try:
        args, action = loads(doc)
        if not action:
            return respond(request, Fault(EX_PROTOCOL, 'Invalid procedure-call'))
        document, = args
        content = str(document['content'])
        author = str(document['author'])
        thistime = time()
        lock, db = open_db()
        try:
            lastedit = db[author]
        except KeyError:
            lastedit = {TIME: thistime, CTIME: 0.0}
        db, lock = close_db(db, lock)
        lasttime = lastedit[TIME]
        ctime = lastedit[CTIME]
        delta = thistime - lasttime
        ctime_per_unit = 0.0
        if not delta == 0.0:
            ctime_per_unit = ctime / delta
        if delta > Config.ctime_unit:
            lasttime = thistime
        elif ctime_per_unit > Config.max_ctime_per_unit:
            # User has exceeded its CPU-ration; and instead
            # of returning a true 503, we'll fashion a more
            # descriptive fault and return OK.
            # return HTTP_SERVICE_UNAVAILABLE
            return respond(request,
                           Fault(EX_UNAVAILABLE, 'Thou hast, dear user, ' +
                                 'exceeded thine resource-allotment'))
                                          
        facility = Config.publicae[action]
        server = ServerProxy('http://%(host)s:%(port)d' %
                             {'host': facility.host,
                              'port': facility.port})
        cstart = time()
        response = respond(request, (server.__getattr__(action).__call__(content),))
        cdelta = time() - cstart
        ctime += cdelta
        thisedit = {TIME: lasttime, CTIME: ctime}
        lock, db = open_db()
        db[author] = thisedit
        db, lock = close_db(db, lock)
    except ExpatError:
        response = respond(request, Fault(EX_PROTOCOL, 'Invalid procedure-call'))
    except KeyError:
        response = respond(request, Fault(EX_DATAERR, 'Unknown procedure-call'))
    except Exception, message:
        response = respond(request, Fault(EX_UNAVAILABLE, str(message)))

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
    def __request (self, methodname, params):
        method_function = ServerProxy.__getattr__(self,methodname)
        self.__params = dict()

        if len(params)>0 and type(params[0]) is dict: self.__params.update(params[0])
        try:
            response = method_function(self.__params)
        except Fault, err:
            raise NameError("Fault", err)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
class AthemeXMLConnection(object):
    def __init__(self, url, ipaddr="0.0.0.0"):
        self.proxy = ServerProxy(url)
        self.chanserv = ChanServ(self)
        self.memoserv = MemoServ(self)
        self.nickserv = NickServ(self)
        self.operserv = OperServ(self)
        self.hostserv = HostServ(self)
        self.infoserv = InfoServ(self)
        self.alis = ALIS(self)
        self._privset = None
        self.ipaddr = ipaddr
        self.username = "*"
        self.authcookie = "*"

    def __getattr__(self, name):
        return self.proxy.__getattr__(name)

    def command(self, service, *parv):
        return self.atheme.command(self.authcookie, self.username, self.ipaddr,
                                   service, *parv)

    def login(self, username, password):
        self.username = username
        self.authcookie = self.atheme.login(username, password)

        self.get_privset()

    def logout(self):
        self.atheme.logout(self.authcookie, self.username)

    def get_privset(self):
        if self._privset is not None:
            return self._privset

        self._privset = self.atheme.privset(self.authcookie, self.username).split()
        return self._privset

    def has_privilege(self, priv):
        try:
            if self.get_privset().index(priv):
                return True
            else:
                return False
        except ValueError:
            return False

    def register(self, username, password, email):
        try:
            return self.atheme.command("*", "*", self.ipaddr, "NickServ", "REGISTER", username, password, email)
        except Fault, e:
            if e.faultString == "A user matching this account is already on IRC.":
                return "Error: " + e.faultString + "  If you are already connected to IRC using this nickname, please complete the registration procedure through IRC."

            return "Error: " + e.faultString

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
 def __request (self, methodname, params):
     if methodname.replace(API_PREFIX,'') not in VALID_METHODS:
         stderr.write( UNKNOWN_METHOD_MESSAGE % {
             'method': methodname.replace(API_PREFIX,''), 'api_prefix': API_PREFIX,
             'api_version': SIPGATE_API_DOC_V, 'api_date': SIPGATE_API_DOC_D } )
     if len(params)>0 and not type(params[0]) is dict:
         raise TypeError(DICT_AS_PARAM_MESSAGE % methodname.replace(API_PREFIX,''))
     method_function = ServerProxy.__getattr__(self,methodname)
     try:
         result = method_function(params[0] if len(params)>0 and type(params[0]) is dict else dict())
         # cast the result dictionary to a SipgateResponse (custom dictionary):
         result = SipgateResponse(result)
     except Fault, e:
         raise SipgateAPIFault(e.faultCode, e.faultString)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
class AthemeXMLConnection(object):
	def __init__(self, url, ipaddr='0.0.0.0'):
		self.proxy    = ServerProxy(url)
		self.chanserv = AthemeChanServMethods(self)
		self.memoserv = AthemeMemoServMethods(self)
		self.nickserv = AthemeNickServMethods(self)
		self.operserv = AthemeOperServMethods(self)
		self.hostserv = AthemeHostServMethods(self)
		self._privset = None
		self.ipaddr   = ipaddr

	def __getattr__(self, name):
		return self.proxy.__getattr__(name)

	def login(self, username, password):
		self.username = username
		self.authcookie = self.atheme.login(username, password)

	def logout(self):
		self.atheme.logout(self.authcookie, self.username)

	def get_privset(self):
		if self._privset is not None:
			return self._privset

		self._privset = self.atheme.privset(self.authcookie, self.username).split()
		return self._privset

	def has_privilege(self, priv):
		try:
			if self.get_privset().index(priv):
				return True
			else:
				return False
		except ValueError, e:
			return False

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
	def __getattr__(self, name):
		return MethodProxy(method = ServerProxy.__getattr__(self, name), name = name, uri = self.__uri)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import __getattr__ [as 别名]
 def __getattr__(self, attr):
   obj = ServerProxy.__getattr__(self, attr)
   if callable(obj):
     obj.__call__ = _ProtocolErrorCatcher(obj.__call__)
   return obj