def proxy(self, factory=None):
"""
Return a new xmlrpc.Proxy for the test site created in
setUp(), using the given factory as the queryFactory, or
self.queryFactory if no factory is provided.
"""
p = xmlrpc.Proxy(networkString("http://127.0.0.1:%d/" % self.port))
if factory is None:
p.queryFactory = self.queryFactory
else:
p.queryFactory = factory
return p
def test_sslTimeout(self):
"""
For I{HTTPS} URIs, L{xmlrpc.Proxy.callRemote} passes the value it
received for the C{connectTimeout} parameter as the C{timeout} argument
to the underlying connectSSL call.
"""
reactor = MemoryReactor()
proxy = xmlrpc.Proxy(b"https://127.0.0.1:69",
connectTimeout=3.0,
reactor=reactor)
proxy.callRemote("someMethod")
self.assertEqual(reactor.sslClients[0][4], 3.0)
def init(self, xml_rpc_url_or_object):
"""
"""
if _Debug:
lg.out(4, 'tcp_interface.init %d' % id(proxy()))
if not proxy():
if isinstance(xml_rpc_url_or_object, six.string_types):
proxy(xmlrpc.Proxy(xml_rpc_url_or_object, allowNone=True))
else:
proxy(xml_rpc_url_or_object)
proxy().callRemote('transport_initialized', 'tcp')
return True
def test_longPassword(self):
"""
C{QueryProtocol} uses the C{base64.b64encode} function to encode user
name and password in the I{Authorization} header, so that it doesn't
embed new lines when using long inputs.
"""
longPassword = self.password * 40
p = xmlrpc.Proxy(networkString("http://127.0.0.1:%d/" % (self.port, )),
self.user, longPassword)
d = p.callRemote("authinfo")
d.addCallback(self.assertEqual, [self.user, longPassword])
return d
def setUp(self):
"""
Create a new XML-RPC server with C{allowNone} set to C{True}.
"""
kwargs = {self.flagName: True}
self.p = reactor.listenTCP(0,
server.Site(Test(**kwargs)),
interface="127.0.0.1")
self.addCleanup(self.p.stopListening)
self.port = self.p.getHost().port
self.proxy = xmlrpc.Proxy(
networkString("http://127.0.0.1:%d/" % (self.port, )), **kwargs)
def rpcCall():
"""
Communicate with our local JMX process to collect results.
This is a generator function
@param driver: generator
@type driver: string
"""
port = self._client.listenPort
xmlRpcProxy = xmlrpc.Proxy('http://localhost:%s/' % port)
d = xmlRpcProxy.callRemote('zenjmx.collect', configMaps)
d.addCallback(processResults)
return d
def init(self, xml_rpc_url_or_object):
"""
"""
if _Debug:
lg.out(4, 'http_interface.init')
if not proxy():
global _GateProxy
if isinstance(xml_rpc_url_or_object, str):
_GateProxy = xmlrpc.Proxy(xml_rpc_url_or_object, allowNone=True)
else:
_GateProxy = xml_rpc_url_or_object
proxy().callRemote('transport_initialized', 'http')
return True
def start(self, eid):
if eid in self.engine_registry:
result = 'already started'
else:
port = runtime.find_port()
self.engine_registry[eid] = xmlrpc.Proxy('http://localhost:%s' %
port)
result = yield self.addProcess(str(eid), [
'/Users/james/Documents/virtualenvs/backplay/bin/python', '-c',
runtime.boot,
str(port)
])
defer.returnValue(result)
def setUp(self):
p = self.proxy = repeatingproxy.RepeatingProxy(xmlrpc.Proxy(url='http://127.0.0.1:54123/'))
#p.is_accepted_failure = self.accepted_failure
p.RPC_TIMEOUT = 0.75
p.TIMEOUT_FACTOR = 1.5
p.DELAY_TIMEOUT = 0.5
p.LONG_CALL = 3.0
p.delay = repeatingproxy.AdaptiveTimeout(p.DELAY_TIMEOUT, factor=p.TIMEOUT_FACTOR)
p.set_timeout(repeatingproxy.IncreasingTimeout(p.RPC_TIMEOUT, factor=p.TIMEOUT_FACTOR))
p.max_retries = 6
p.serializing = True
self.handler = TestHandler()
self.site = server.Site(self.handler, timeout=30)
self.tcp_port = None
def join_cluster(self, hostport):
s = xmlrpc.Proxy("http://%s/RPC2" % (hostport))
def done(result):
action_id, redCut, snapshot = result
action_id = replication.ActionId().decode(action_id)
df = self.delegate.processSnapshot(snapshot.data)
def start(res, self, action_id, redCut):
self.rep.startMainProtocol(action_id, redCut)
self.initializeDatabase(self.rep.db)
df.addCallback(start, self, action_id, redCut)
df = s.callRemote("join_cluster", self.group, self.rep.serverId)
df.addCallback(done)
def init(self, xml_rpc_url_or_object):
"""
"""
global _GateProxy
if _Debug:
lg.out(4, 'proxy_interface.init')
from transport.proxy import proxy_receiver
from transport.proxy import proxy_sender
if isinstance(xml_rpc_url_or_object, str):
_GateProxy = xmlrpc.Proxy(xml_rpc_url_or_object, allowNone=True)
else:
_GateProxy = xml_rpc_url_or_object
proxy_receiver.A('init')
proxy_sender.A('init')
proxy().callRemote('transport_initialized', 'proxy')
return True
def __init__(self, addr):
"""Create a client that will connect to addr.
Once created, this class will autoconnect and reconnect to the
controller as needed.
:Parameters:
addr : tuple
The (ip, port) of the IMultiEngine adapted controller.
"""
self.addr = addr
self.url = 'http://%s:%s/' % self.addr
self._proxy = webxmlrpc.Proxy(self.url)
self._deferredIDCallbacks = {}
# This class manages some pending deferreds through this instance. This
# is required for methods like gather/scatter as it enables us to
# create our own pending deferreds for composite operations.
self.pdm = PendingDeferredManager()
def message(self, uri, message, content):
groups = self.parseURI(uri)
# Add the implicit /RPC2 and http://, creating a server proxy object
server = groups['server']
if server.find('/') < 0:
server = server + '/RPC2'
server = 'http://' + server
proxy = xmlrpc.Proxy(server)
# Parse arguments, allowing use of our 'message' and 'content' variables.
args = self.parseArgs(groups['args'],
message = str(message),
content = content)
# Make the call, ignoring the resulting Deferred. If it succeeds,
# we don't really care. If it fails, the error will get logged.
proxy.callRemote(groups['function'], *args)
def _publisher_thread(self, url):
while True:
try:
proxy = rosxmlrpc.Proxy(xmlrpc.Proxy(url), self._node_handle._name)
value = yield proxy.requestTopic(self._name, [['TCPROS']])
protocol, host, port = value
conn = yield endpoints.TCP4ClientEndpoint(reactor, host, port).connect(
util.AutoServerFactory(lambda addr: tcpros.Protocol()))
try:
conn.sendString(tcpros.serialize_dict(dict(
message_definition=self._type._full_text,
callerid=self._node_handle._name,
topic=self._name,
md5sum=self._type._md5sum,
type=self._type._type,
)))
header = tcpros.deserialize_dict((yield conn.receiveString()))
self._connections[conn] = header.get('callerid', None)
try:
while True:
data = yield conn.receiveString()
msg = self._type().deserialize(data)
try:
self._callback(msg)
except:
traceback.print_exc()
self._last_message = msg
self._last_message_time = self._node_handle.get_time()
old, self._message_dfs = self._message_dfs, []
for df in old:
df.callback(msg)
finally:
del self._connections[conn]
finally:
conn.transport.loseConnection()
except (error.ConnectionDone, error.ConnectionLost, error.ConnectionRefusedError):
pass
except Exception:
traceback.print_exc()
yield util.wall_sleep(1) # pause so that we don't repeatedly reconnect immediately on failure
def __init__(self,
name,
handler,
topic,
topic_type,
caller_api,
ros_master_uri=None):
if ros_master_uri is None:
ros_master_uri = os.environ['ROS_MASTER_URI']
self.handler = handler # to be called when a new message comes in
self.caller_id = rospy.names.resolve_name(name)
from twisted.web import xmlrpc
self.master = xmlrpc.Proxy(ros_master_uri)
self.topic = topic
self.topic_type = topic_type
self.caller_api = caller_api # local xml uri
def __init__(self,
handler,
service_class,
name,
ros_service,
rpc_uri,
caller_api,
ros_master_uri=None):
if ros_master_uri is None:
ros_master_uri = os.environ['ROS_MASTER_URI']
self.handler = handler
self.service_class = service_class
self.resolved_name = rospy.names.resolve_name(ros_service)
self.caller_id = rospy.names.resolve_name(name)
from twisted.web import xmlrpc
self.master = xmlrpc.Proxy(ros_master_uri)
self.rpc_uri = rpc_uri # local rpc
self.caller_api = caller_api # xmlrpc local uri
def setup_transport(self):
log.msg('Starting the OperaInboundTransport config: %s' %
self.transport_name)
self.r_server = redis.Redis(**self.r_config)
self.r_prefix = "%(transport_name)s@%(url)s" % self.config
self.proxy = xmlrpc.Proxy(self.opera_url)
self.default_values = {
'Service': self.opera_service,
'Password': self.opera_password,
'Channel': self.opera_channel,
}
# start receipt web resource
self.web_resource = yield self.start_web_resources([
(OperaReceiptResource(
self.handle_raw_incoming_receipt), self.web_receipt_path),
(OperaReceiveResource(
self.publish_message), self.web_receive_path),
(OperaHealthResource(), 'health'),
], self.web_port)
def makeBuilderSlave(cls,
builder_url,
vm_host,
timeout,
reactor=None,
proxy=None):
"""Create and return a `BuilderSlave`.
:param builder_url: The URL of the slave buildd machine,
e.g. http://localhost:8221
:param vm_host: If the slave is virtual, specify its host machine
here.
:param reactor: Used by tests to override the Twisted reactor.
:param proxy: Used By tests to override the xmlrpc.Proxy.
"""
rpc_url = urlappend(builder_url.encode('utf-8'), 'rpc')
if proxy is None:
server_proxy = xmlrpc.Proxy(rpc_url,
allowNone=True,
connectTimeout=timeout)
server_proxy.queryFactory = QuietQueryFactory
else:
server_proxy = proxy
return cls(server_proxy, builder_url, vm_host, timeout, reactor)
def proxy(self):
return xmlrpc.Proxy("http://127.0.0.1:%d" % (self.port, ),
allowNone=True)
def proxy(self):
p = xmlrpc.Proxy("http://127.0.0.1:%d" % self.port)
p.queryFactory = self.queryFactory
return p
def createServer(self, resource):
self.p = reactor.listenTCP(
0, server.Site(resource), interface="127.0.0.1")
self.addCleanup(self.p.stopListening)
self.port = self.p.getHost().port
self.proxy = xmlrpc.Proxy('http://127.0.0.1:%d' % self.port)
def test_explicitAuthInfoOverride(self):
p = xmlrpc.Proxy("http://*****:*****@127.0.0.1:%d/" % (
self.port,), self.user, self.password)
d = p.callRemote("authinfo")
d.addCallback(self.assertEquals, [self.user, self.password])
return d
def _main(self, job_id):
worker = CodeImportWorkerMonitor(
job_id, self.logger,
xmlrpc.Proxy(config.codeimportdispatcher.codeimportscheduler_url),
self.options.access_policy)
return worker.run()
def __init__(self, addr_str='http://localhost:5000'):
self.proxy = xmlrpc.Proxy(addr_str)
def __init__(self, rptSystem=None):
OaF.Notifier.__init__(self, rptSystem)
self.xmlProxy = xmlrpc.Proxy(
"http://xmlrpc.secondlife.com/cgi-bin/xmlrpc.cgi")
self.rptSystem = rptSystem
def test_explicitAuthInfo(self):
p = xmlrpc.Proxy(networkString("http://127.0.0.1:%d/" % (
self.port,)), self.user, self.password)
d = p.callRemote("authinfo")
d.addCallback(self.assertEqual, [self.user, self.password])
return d
def test_authInfoInURL(self):
p = xmlrpc.Proxy("http://%s:%[email protected]:%d/" % (
self.user, self.password, self.port))
d = p.callRemote("authinfo")
d.addCallback(self.assertEquals, [self.user, self.password])
return d
def __init__(self, port):
"""
"""
self.client = xmlrpc.Proxy("http://localhost:%s" % port)
self.engine_id = ''
self.backend = None
def __new__(cls, ns, name, addr, master_uri, remappings):
# constraints: anything blocking here should print something if it's
# taking a long time in order to avoid confusion
self = object.__new__(cls)
if ns:
assert ns[0] == '/'
assert not ns.endswith('/')
self._ns = ns # valid values: '', '/a', '/a/b'
assert '/' not in name
self._name = self._ns + '/' + name
self._shutdown_callbacks = set()
reactor.addSystemEventTrigger('before', 'shutdown', self.shutdown)
self._addr = addr
self._master_uri = master_uri
self._remappings = remappings
self._master_proxy = rosxmlrpc.Proxy(xmlrpc.Proxy(self._master_uri),
self._name)
self._is_running = True
self._xmlrpc_handlers = {}
self._xmlrpc_server = reactor.listenTCP(
0, server.Site(_XMLRPCSlave(self)))
self._shutdown_callbacks.add(self._xmlrpc_server.loseConnection)
self._xmlrpc_server_uri = 'http://%s:%i/' % (
self._addr, self._xmlrpc_server.getHost().port)
self._tcpros_handlers = {}
@util.cancellableInlineCallbacks
def _handle_tcpros_conn(conn):
try:
header = tcpros.deserialize_dict((yield conn.receiveString()))
def default(header, conn):
conn.sendString(
tcpros.serialize_dict(
dict(error='unhandled connection')))
conn.transport.loseConnection()
if 'service' in header:
self._tcpros_handlers.get(('service', header['service']),
default)(header, conn)
elif 'topic' in header:
self._tcpros_handlers.get(('topic', header['topic']),
default)(header, conn)
else:
conn.sendString(
tcpros.serialize_dict(
dict(error='no topic or service name detected')))
conn.transport.loseConnection()
except:
conn.transport.loseConnection()
raise
def _make_tcpros_protocol(addr):
conn = tcpros.Protocol()
_handle_tcpros_conn(conn)
return conn
self._tcpros_server = reactor.listenTCP(
0, util.AutoServerFactory(_make_tcpros_protocol))
self._shutdown_callbacks.add(self._tcpros_server.loseConnection)
self._tcpros_server_uri = 'rosrpc://%s:%i' % (
self._addr, self._tcpros_server.getHost().port)
self._tcpros_server_addr = self._addr, self._tcpros_server.getHost(
).port
while True:
try:
other_node_uri = yield self._master_proxy.lookupNode(
self._name)
except rosxmlrpc.Error:
break # assume that error means unknown node
except Exception:
traceback.print_exc()
yield util.wall_sleep(1) # pause so we don't retry immediately
else:
other_node_proxy = rosxmlrpc.Proxy(
xmlrpc.Proxy(other_node_uri), self._name)
try:
yield util.wrap_timeout(
other_node_proxy.shutdown(
'new node registered with same name'), 3)
except error.ConnectionRefusedError:
pass
except Exception:
traceback.print_exc()
break
try:
self._use_sim_time = yield self.get_param('/use_sim_time')
except rosxmlrpc.Error: # assume that error means not found
self._use_sim_time = False
if self._use_sim_time:
def got_clock(msg):
self._sim_time = msg.clock
self._clock_sub = self.subscribe('/clock', Clock, got_clock)
# make sure self._sim_time gets set before we continue
yield util.wrap_time_notice(self._clock_sub.get_next_message(), 1,
'getting simulated time from /clock')
for k, v in self._remappings.iteritems():
if k.startswith('_') and not k.startswith('__'):
yield self.set_param(self.resolve_name('~' + k[1:]),
yaml.load(v))
self.advertise_service('~get_loggers', GetLoggers,
lambda req: GetLoggersResponse())
self.advertise_service('~set_logger_level', SetLoggerLevel,
lambda req: SetLoggerLevelResponse())
defer.returnValue(self)
def __init__(self):
self.wiki = xmlrpc.Proxy('http://localhost:8082/RPC2')