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