def make_portal():
"""Create and return a `Portal` for the SSH service.
This portal accepts SSH credentials and returns our customized SSH
avatars (see `CodehostingAvatar`).
"""
authentication_proxy = Proxy(config.codehosting.authentication_endpoint)
codehosting_proxy = Proxy(config.codehosting.codehosting_endpoint)
return get_portal(authentication_proxy, codehosting_proxy)
def start(self):
proxy = Proxy("http://beatty.userland.com/RPC2")
if TEST_ERRORS:
i = self.i
if i == 3:
proxy = Proxy("http://illegal-host_name/")
elif i == 6:
proxy = Proxy("http://beatty.userland.com/")
elif i == 8:
proxy = Proxy(
"http://beatty.userland.com/testing_xmlrpc_error_case")
return proxy.callRemote('examples.getStateName', self.i)
class Snipplr(object):
"""docstring for Snipplr"""
api_key = None
proxy = Proxy('http://snipplr.com/xml-rpc.php')
def __init__(self):
super(Snipplr, self).__init__()
def printValue(self,value):
for sni in value: print sni
# print len(value)
reactor.stop()
def printError(self,error):
print 'error', error
reactor.stop()
def _call(self,api, *arg):
"""docstring for call"""
self.proxy.callRemote(api, *arg).addCallbacks(self.printValue, self.printError)
return reactor.run()
def get(self, id):
self._call('snippet.get', id)
def list(self):
self._call('snippet.list', self.api_key)
def uploadImage(self, name, data):
exception = self.master.modules["commands"].exception
user = yield self.config.get("user")
passwd = yield self.config.get("pass")
if user is None or passwd is None:
raise exception(u"No blog username or password in config")
blog = Proxy("http://commiesubs.com/xmlrpc.php")
blog.queryFactory.noisy = False
try:
data = yield blog.callRemote(
"wp.uploadFile",
0, # Blog ID
user, # Username
passwd, # Password
{ # Content
"name": name,
"type": "image/jpeg",
"bits": xmlrpclib.Binary(data),
"overwrite": True
})
except:
raise exception(u"Couldn't upload image")
returnValue(data["url"])
def updateMahoyo(self, progress):
progress = BeautifulSoup(progress)
exception = self.master.modules["commands"].exception
user = yield self.config.get("user")
passwd = yield self.config.get("pass")
if user is None or passwd is None:
raise exception(u"No blog username or password in config")
blog = Proxy("http://commiesubs.com/xmlrpc.php")
blog.queryFactory.noisy = False
post = yield blog.callRemote("wp.getPost", 0, user, passwd, 8367)
content = BeautifulSoup(post["post_content"])
old = content.find(class_="progress")
new = progress.find(class_="progress")
old.replace_with(new)
content = content.encode(formatter="html")
try:
yield blog.callRemote("wp.editPost", 0, user, passwd, 8367,
{"post_content": content})
except:
raise exception(u"Couldn't update post")
def stopProducingStream(streamId, p2nerIp='127.0.0.1', p2nerPort=PORT):
print 'should stop producing ', STREAMID
url = 'http://' + p2nerIp + ':' + str(p2nerPort)
proxy = Proxy(url)
d = proxy.callRemote('stopProducing', STREAMID)
d.addCallback(stopSuccess)
d.addErrback(stopFailure)
def _get_proxy(self):
if self._proxy is None:
config = get_config()
address = config.get('General', 'serveraddress')
if not address:
with api.new_store() as store:
query = ("SELECT client_addr FROM pg_stat_activity "
"WHERE application_name LIKE ? AND "
" datname = ? "
"LIMIT 1")
params = [u'stoqserver%', unicode(db_settings.dbname)]
res = store.execute(query, params=params).get_one()
address = res and res[0]
if not address:
raise ServerError(_("Stoq server not found"))
port = config.get('General', 'serverport') or 6970
url = 'http://%s:%s/XMLRPC' % (address, port)
self._proxy = Proxy(url)
try:
yield self._check_proxy(self._proxy)
except Exception:
self._proxy = None
raise
api.asyncReturn(self._proxy)
def setUp(self):
self.root = resource.buildResource('127.0.0.1:99999')
self.site = Site(self.root) # TODO: what is timeout?
self.serv = reactor.listenTCP(0, self.site, interface='127.0.0.1')
P = self.serv.getHost().port
url = 'http://127.0.0.1:%d/cgi-bin/ArchiveDataServer.cgi' % P
self.client = Proxy(url)
def getMethods(self, url):
_server = self.k_server = Proxy(url.encode("utf8"))
self.startWorking()
return (
_server.callRemote("listMethods")
.addCallback(
# call self.receivedMethods(result, _server, "") on success
self.receivedMethods,
_server,
"",
)
.addErrback(
# on error, call this lambda
lambda e: _server.callRemote("system.listMethods").addCallback(
# call self.receievedMethods(result, _server, "system.")
self.receivedMethods,
_server,
"system.",
)
)
.addErrback(
# log the failure instance, with a method
self.receivedMethodsFailure,
"listMethods()",
)
.addBoth(
# stop working nomatter what trap all errors (returns None)
lambda n: self.stopWorking()
)
)
def _callRemote(self, method, *args, **kwds):
proxy = Proxy("http://%s/XMLRPC" % self.host, user=self.username,
password=self.password, allowNone=True)
deferred = proxy.callRemote(method, *args, **kwds)
deferred.addCallbacks(self.onResult, self.onError)
deferred.addCallbacks(self._stopReactor, self._stopReactor)
reactor.run()
return 0
def __init__(self, vip, vport, port=9000, testbed=False):
xmlrpc.XMLRPC.__init__(self)
print 'start listening xmlrpc'
reactor.listenTCP(port, server.Site(self))
url = "http://" + vip + ':' + str(vport) + "/XMLRPC"
self.proxy = Proxy(url)
self.register(port)
self.testbed = testbed
def run(self):
self._proxy = Proxy("http://%s/XMLRPC" % self.host,
user=self.username,
password=self.password,
allowNone=True)
# make the XMLRPC call
self.tail(None)
reactor.run()
def startService(self):
Window.startService(self)
logger.debug("started tail: using query '%s'" % self._query)
self._proxy = Proxy(self._url,
user=self._user,
password=self._pass,
allowNone=True)
self._tail()
def initInterface(self,*args,**kwargs):
xmlrpc.XMLRPC.__init__(self)
self.logger=DatabaseLog(_parent=self,server=True)
print 'should register to ',kwargs['vizirIP'],kwargs['vizirPort']
url="http://"+kwargs['vizirIP']+':'+str(kwargs['vizirPort'])+"/XMLRPC"
self.vip=kwargs['vizirIP']
self.vport=kwargs['vizirPort']
self.proxy=Proxy(url)
def __init__(self,url,**kwargs):
self.url = url.encode('gb2312')
_allowNone = kwargs.get('allowNone', False)
_timeOut = kwargs.get('connectTimeout', 30.0)
try:
proxy = Proxy(self.url,allowNone=_allowNone,connectTimeout=_timeOut)
except Exception,e:
SysLog(1,"XMLRPCClient.init fail as [%s]"%(str(e)))
def __init__(self, url):
"""
Initialize the store.
"""
self.store = dict()
self.url = url
self.proxy = Proxy(self.url)
self.error = False
def test_cannotSetDateTime(self):
"""
Setting L{XMLRPC.useDateTime} to C{True} after initialization raises
L{RuntimeError}.
"""
xmlrpc = XMLRPC(useDateTime=False)
self.assertRaises(RuntimeError, setattr, xmlrpc, "useDateTime", True)
proxy = Proxy("http://localhost/", useDateTime=False)
self.assertRaises(RuntimeError, setattr, proxy, "useDateTime", True)
def on_connectButton_clicked(self,widget):
ip=self.builder.get_object('ipEntry').get_text()
port=self.builder.get_object('portEntry').get_text()
self.url="http://"+ip+':'+port+"/XMLRPC"
print self.url
proxy = Proxy(self.url)
d =proxy.callRemote('connect')
d.addCallback(self.succesfulConnection)
d.addErrback(self.failedConnection)
def createPost(self,
show,
episode,
version,
info_link,
img_link,
comment=None,
hovertext=None):
end = " END" if episode == show.episode.total else ""
exception = self.master.modules["commands"].exception
img = '<img src="{}" title="{}" style="width: 100%; border-radius: 5px;" />'.format(
img_link,
"" if hovertext is None else hovertext.replace('"', '"'))
comment = "<br><br>{}".format(
comment.encode("utf8")) if comment is not None else ""
user = yield self.config.get("user")
passwd = yield self.config.get("pass")
if user is None or passwd is None:
raise exception(u"No blog username or password in config")
blog = Proxy("http://commiesubs.com/xmlrpc.php")
blog.queryFactory.noisy = False
slug = re.search("([^/]+)/?$", show.blog).group(1)
categories = ["The Bread Lines"] #, "DxS a shit"]
result = yield blog.callRemote("wp.getTerms", 0, user, passwd,
"category")
for term in result:
if term["slug"] == slug:
categories.append(term["name"])
try:
yield blog.callRemote(
"wp.newPost",
0, # Blog ID
user, # Username
passwd, # Password
{ # Content
"post_type":
"post",
"post_status":
"publish",
"comment_status":
"open",
"post_title":
"{} {:02d}{}{}".format(show.name.english, episode, version,
end),
"post_content":
"{}<br><br><a href=\"{}\">Torrent</a>{}".format(
img, info_link, comment),
"terms_names": {
"category": categories
}
})
except:
raise exception(u"Couldn't publish blog post")
def xmlrpc_proxyCommand(self, *args):
#cmd=args.pop(0)
args = list(args)
peer = args.pop(-1)
if self.testbed:
peer[0] = LTOGIP[peer[0]]
url = "http://" + peer[0] + ':' + str(peer[1]) + "/XMLRPC"
proxy = Proxy(url)
d = proxy.callRemote(*args)
return d
def main():
"""
script main function
"""
url = 'http://%s:%s' % (CFG['client']['server'], CFG['client']['port'])
proxy = Proxy(url)
proxy.callRemote('request', 1,
'http://127.0.0.1/dolphin/callback').addCallbacks(
success_callback, error_callback)
reactor.run()
def retryWithOtherProvider(self, error, nodeConfig, words, docId, filename):
if self.providerSet:
nextHost, nextPort = self.providerSet.pop()
print "[webapp] trying to donwload %r from %s:%s" % (filename, nextHost, nextPort)
proxy = Proxy(str('http://%s:%s' % (nextHost, nextPort)))
d = proxy.callRemote('downloadFile', docId, words)
d.addCallback(self.gotDataBack, nodeConfig, filename, words)
d.addErrback(self.retryWithOtherProvider, nodeConfig, words, docId, filename)
return d
else:
return self.onDownloadFileError('no provider available', filename)
def reload(self):
if self._deferred != None:
self._deferred.cancel()
self._results.clear()
proxy = Proxy(self._url,
user=self._user,
password=self._pass,
allowNone=True)
self._deferred = proxy.callRemote('iterEvents', self._query)
self._deferred.addCallback(self._getResult)
self._deferred.addErrback(self._getError)
logger.debug("searching with query '%s'" % self._query)
def run(self):
proxy = Proxy("http://%s/XMLRPC" % self.host,
user=self.username,
password=self.password,
allowNone=True)
deferred = proxy.callRemote('iterEvents', self.query, None,
self.indices, self.limit, self.reverse,
self.fields)
deferred.addCallback(self.printResult)
deferred.addErrback(self.printError)
reactor.run()
return 0
def test_inbound_request_and_reply(self):
address = self.transport.xmlrpc_server.getHost()
url = 'http://' + address.host + ':' + str(address.port) + '/foo/'
proxy = Proxy(url)
x = proxy.callRemote('handleUSSD', {
'TransactionId': '0001',
'USSDServiceCode': '543',
'USSDRequestString': '14321*1000#',
'MSISDN': '275551234',
'USSDEncoding': 'GSM0338', # Optional
'TransactionTime': '2013-07-05T22:58:47.565596'
})
[msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
expected_inbound_payload = {
'message_id': '',
'content': None,
'from_addr': '', # msisdn
'to_addr': '', # service code
'session_event': TransportUserMessage.SESSION_RESUME,
'transport_name': self.tx_helper.transport_name,
'transport_type': 'ussd',
'transport_metadata': {
'mtn_rwanda_ussd': {
'transaction_id': '0001',
'transaction_time': '2013-07-05T22:58:47.565596',
},
},
}
yield self.assert_inbound_message(
expected_inbound_payload,
msg,
from_addr='275551234',
to_addr='543',
session_event=TransportUserMessage.SESSION_NEW)
expected_reply = {'MSISDN': '275551234',
'TransactionId': '0001',
'TransactionTime': datetime.now().isoformat(),
'USSDEncoding': 'GSM0338',
'USSDResponseString': 'Test message',
'USSDServiceCode': '543',
'action': 'end'}
self.tx_helper.make_dispatch_reply(
msg, expected_reply['USSDResponseString'], continue_session=False)
received_text = yield x
for key in received_text.keys():
if key == 'TransactionTime':
self.assertEqual(len(received_text[key]),
len(expected_reply[key]))
else:
self.assertEqual(expected_reply[key], received_text[key])
def __init__(self, xmlrpc_port=33610, xmlrpc_use_ssl=True, api_key=None):
Resource.__init__(self)
url = '%(protocol)s://127.0.0.1:%(port)d/CloudMailing' % {
'protocol': xmlrpc_use_ssl and 'https' or 'http',
'port': xmlrpc_port
}
self.proxy = Proxy(url,
user='******',
password=api_key,
allowNone=True,
useDateTime=True,
connectTimeout=30.0)
def on_connectButton_clicked(self, widget):
self.ip = self.builder.get_object('ipEntry').get_text()
port = self.builder.get_object('portEntry').get_text()
self.url = "http://" + self.ip + ':' + port + "/XMLRPC"
proxy = Proxy(self.url)
password = self.builder.get_object('passwordEntry').get_text()
m = md5()
m.update(password)
password = m.hexdigest()
d = proxy.callRemote('connect', password)
d.addCallback(self.succesfulConnection)
d.addErrback(self.failedConnection)
def __init__(self, parent):
"""
Initialize
"""
RenderableResource.__init__(self, parent)
self.action = ""
self.properties = ""
self.style = ""
self.client = None
# Remote XML-RPC server
log.debug("Preparing remote XML-RPC server: %s" %
self.config.stylesRepository.encode("ascii"))
self.proxy = Proxy(self.config.stylesRepository.encode("ascii"))
def initInterface(self, *args, **kwargs):
xmlrpc.XMLRPC.__init__(self)
self.dContactServers = {}
self.dSubStream = {}
self.dStopProducing = {}
self.dUnregisterStream = {}
self.dRegisterStream = {}
if 'vizir' in kwargs.keys() and kwargs['vizir']:
print 'should register to ', kwargs['vizirIP'], kwargs['vizirPort']
url = "http://" + kwargs['vizirIP'] + ':' + str(
kwargs['vizirPort']) + "/XMLRPC"
self.proxy = Proxy(url)
else:
self.proxy = None
def __init__(self, profile):
self.profile = profile
self.url = self.lookup(profile, 'server')
self.weburl = self.lookup(profile, 'weburl')
if not self.url:
msg = 'no server configured at %s for %s' % (PROFILES, profile)
raise ValueError(msg)
self.proxy = Proxy(self.url.encode(), allowNone=True)
self.proxy.queryFactory = KojiQueryFactory
self.cache = Cache(self)
# We populate these on login:
self.session_id = None
self.session_key = None
self.callnum = None
