def __init__(self, host, port, json_callback, backout_callback, usessl):
self.host = host
self.port = int(port)
#Callback fired on receiving response to send()
self.json_callback = json_callback
#Callback fired on receiving any response failure
self.backout_callback = backout_callback
if usessl:
self.proxy = Proxy('https://' + host + ":" + str(port) + "/",
ssl_ctx_factory=AltCtxFactory)
else:
self.proxy = Proxy('http://' + host + ":" + str(port) + "/")
def get_api_worker(self, config=None, start=True, auth=True):
config = {} if config is None else config
config.setdefault('worker_name', 'test_api_worker')
config.setdefault('twisted_endpoint', 'tcp:0')
config.setdefault('web_path', 'api')
config.setdefault('health_path', 'health')
config = self.vumi_helper.mk_config(config)
worker = yield self.vumi_helper.get_worker_helper().get_worker(
GoApiWorker, config, start)
vumi_api = worker.vumi_api
self.vumi_helper.set_vumi_api(vumi_api)
user, password = None, None
if auth:
user_helper = yield self.vumi_helper.make_user(u"user-1")
session_id = "session-1"
session = {}
vumi_api.session_manager.set_user_account_key(
session, user_helper.account_key)
yield vumi_api.session_manager.create_session(session_id,
session,
expire_seconds=30)
user, password = "******", session_id
if not start:
returnValue(worker)
yield worker.startService()
port = worker._web_service._waitingForPort.result
addr = port.getHost()
proxy = Proxy("http://%s:%d/api/" % (addr.host, addr.port),
user=user,
password=password)
returnValue((worker, proxy))
def __registration(self):
port = self.__listening_port
if ((self.__bc_ipaddr == None) or \
(self.__bc_listening_port == None)):
print "no BC ip or port specified, skipping registration"
self.__registration_loop.stop()
return
bc_register = Proxy('http://%s:%d/' %
(self.__bc_ipaddr, self.__bc_listening_port))
if self.__bc_connected:
d = bc_register.callRemote('keepalive', self.__local_ip, port)
else:
host_specs = HostSpecsManager().get_host_specs()
specs = jsonpickle.encode(host_specs)
from core.blockinfo import block_infos
blocks = block_infos.keys()
blocks_descr = [block_infos[b] for b in blocks]
descr = jsonpickle.encode(blocks_descr)
#blocks_descr = [str(block_infos[b]) for b in blocks]
#d = bc_register.callRemote('register', self.__local_ip, port, specs, blocks)
#d = bc_register.callRemote('register', self.__local_ip, port, specs, blocks, blocks_descr)
d = bc_register.callRemote('register', self.__local_ip, port,
specs, blocks, descr)
d.addCallback(self.__registration_results).addErrback(
self.__registration_error)
def main():
print("\033[94mJSON-RPC client started\033[0m")
# Server connection data we want to connect
serverIP = "localhost"
port = "12345"
# Enables the Twisted debug mode, if needed
debugmode = False
# Creates the JSONRPC Connection with our context factory to
# authenticate us against the server with our private key and ensure a
# strong encryption method as well as setting our trusted CA for our
# server connection.
proxy = Proxy('https://%s:%s' % (serverIP,
port),
ssl_ctx_factory=AltCtxFactory)
# Calling function "echo" at server "proxy", using printValue if
# everything went fine, using printError if somethging went wrong
# as callback function.
# Passing the message "Servertest passed" to the RPC Server, which returns
# that value if erverything went fine.
callRemote(proxy, "echo", printValue, printError, "Servertest passed")
# Calling function "multiply" at server "proxy", using printValue if
# everything went fine, using printError if somethging went wrong
# as callback function.
# Passing the integers to the RPC Server, which returns
# the result 42 if erverything went fine.
callRemote(proxy, "multiply", printMultiplyResult, printError, 6, 7)
# Enable the Twisted logging module if defined
if(debugmode):
from twisted.python import log
log.startLogging(sys.stdout)
# Starting our Client jobs
reactor.run()
def setUp(self):
self.PORT = 7070
self.daemon = Proxy('http://127.0.0.1:%d/' % self.PORT)
self.tdef = "../templatedef.xml"
self.tins = "../templateins.xml"
self.tdef_id = "pkt_counter_aggregator"
self.tins_id = "pkt_counter_aggregator"
def setUp(self):
self.persistence_helper = self.add_helper(PersistenceHelper())
self.redis = yield self.persistence_helper.get_redis_manager()
self.tagpool = TagpoolManager(self.redis)
site = Site(TagpoolApiServer(self.tagpool))
self.server = yield reactor.listenTCP(0, site, interface='127.0.0.1')
self.add_cleanup(self.server.loseConnection)
addr = self.server.getHost()
self.proxy = Proxy("http://%s:%d/" % (addr.host, addr.port))
yield self.setup_tags()
def setUp(self):
self.port = reactor.listenTCP(
8001, RemoteShutterFactory(ShutterJSONRPCProtocol()))
self.client = Proxy('http://127.0.0.1:8001',
version=jsonrpclib.VERSION_2)
self.conn = psycopg2.connect(config.DB_CONN)
self.cur = self.conn.cursor()
if not os.path.exists("static"):
os.makedirs("static")
def setUp(self):
self.vumi_helper = yield self.add_helper(VumiApiHelper())
self.user_helper = yield self.vumi_helper.make_user(u'user')
self.user_api = self.user_helper.user_api
self.campaign_key = self.user_helper.account_key
site = Site(
GoApiServer(self.campaign_key, self.vumi_helper.get_vumi_api()))
self.server = yield reactor.listenTCP(0, site)
self.add_cleanup(self.server.loseConnection)
addr = self.server.getHost()
self.proxy = Proxy("http://%s:%d/" % (addr.host, addr.port))
def get_api_worker(self, config=None, start=True):
config = {} if config is None else config
config.setdefault('worker_name', 'test_api_worker')
config.setdefault('twisted_endpoint', 'tcp:0')
config.setdefault('web_path', 'api')
config.setdefault('health_path', 'health')
config = self.persistence_helper.mk_config(config)
worker = yield self.worker_helper.get_worker(TagpoolApiWorker, config,
start)
self.add_cleanup(self.cleanup_worker, worker)
if not start:
returnValue(worker)
yield worker.startService()
port = worker.services[0]._waitingForPort.result
addr = port.getHost()
proxy = Proxy("http://%s:%d/api/" % (addr.host, addr.port))
returnValue((worker, proxy))
def __init__(self, config_file, timeout=None):
self.timeout = timeout
with open(config_file) as f:
content = f.read().splitlines()
config = {
split[0]: split[1]
for split in [row.split('=', 1) for row in content if len(row)]
}
if 'testnet' in config:
port = 18332
else:
port = 8332
rpcuser = config['rpcuser']
rpcpassword = config['rpcpassword']
self.proxy = Proxy('http://%s:%[email protected]:%d' %
(rpcuser, rpcpassword, port))
def main():
parser = argparse.ArgumentParser(description="Send an rpc command to a dht node")
parser.add_argument("rpc_command",
help="The rpc command to send to the dht node")
parser.add_argument("--node_host",
help="The host of the node to connect to",
default="127.0.0.1")
parser.add_argument("--node_port",
help="The port of the node to connect to",
default="8888")
args = parser.parse_args()
connect_string = 'http://%s:%s' % (args.node_host, args.node_port)
proxy = Proxy(connect_string)
d = proxy.callRemote(args.rpc_command)
d.addCallbacks(print_value, print_error)
d.addBoth(lambda _: shut_down())
reactor.run()
pri = os.getenv('MPLANE_RI')
if pri is None:
raise ValueError("environment variable MPLANE_RI has not been set")
sys.path.append(pri)
import mplane.model
import mplane.scheduler
import mplane.utils
import mplane.component
_module_path = os.path.dirname(os.path.abspath(__file__))
_capabilitypath = os.path.join(_module_path, "capabilities")
_controller_address = "127.0.0.1"
_controller_port = 7070
_controller_daemon = Proxy('http://%s:%d/' % (_controller_address,
_controller_port))
"""
Implements Blockmon Controller capabilities and services
"""
def services():
services = []
services.append(blockmonControllerService(packets_capability()))
return services
def packets_capability():
cap = mplane.model.Capability(label="blockmon-controller-packets",
if inline:
print repr(value).decode("unicode-escape").encode('utf-8')
else:
import pprint
pprint.pprint(value)
def printError(error):
print ' !! ERROR: ', error
def shutdown(data):
reactor.stop()
proxy = Proxy('http://127.0.0.1:%d' % config['twisted']['port'])
command = sys.argv[startargs - 1]
args = []
is_array = False
for a in sys.argv[startargs:]:
if a == "array":
is_array = True
else:
if is_array:
if a.startswith('[') and a.endswith(']'):
args.append(eval(a))
elif not len(a):
args.append([])
else:
args.append([a])
else:
from txjsonrpc.web.jsonrpc import Proxy
def printValue(value):
print "Result: %s" % str(value)
def printError(error):
print 'error', error
def shutDown(data):
print "Shutting down reactor..."
reactor.stop()
proxy = Proxy('http://127.0.0.1:6969/')
dl = []
d = proxy.callRemote('echo', 'bite me')
d.addCallbacks(printValue, printError)
dl.append(d)
d = proxy.callRemote('math.add', 3, 5)
d.addCallbacks(printValue, printError)
dl.append(d)
dl = defer.DeferredList(dl)
dl.addCallback(shutDown)
reactor.run()
def printValue(value):
if inline == "json":
print json.dumps(value)
elif inline:
print repr(value).decode("unicode-escape").encode('utf-8')
else:
import pprint
pprint.pprint(value)
def printError(error):
print ' !! ERROR: ', error
def shutdown(data):
reactor.stop()
proxy = Proxy('http://127.0.0.1:%d' % config['core_api_port'])
command = sys.argv[startargs - 1]
args = []
is_array = False
for a in sys.argv[startargs:]:
if a == "array":
is_array = True
else:
if is_array:
if (a.startswith('[') and a.endswith(']')) or (a.startswith('{') and a.endswith('}')):
args.append(eval(a))
elif not len(a):
args.append([])
else:
args.append([a])
elif a == "False" or a == "True":
def getWE(dl) :
d = proxy.callRemote('getWebEntities')
d.addCallbacks(printValue, printError)
dl.append(d)
d = proxy.callRemote('monitorCrawl')
d.addCallbacks(printValue, printError)
dl.append(d)
watchWE(dl)
def watchWE(dl) :
d=reactor.callLater(1,getWE,dl)
dl.append(d)
proxy = Proxy('http://127.0.0.1:8080/')
dl = []
watchWE(dl)
d = proxy.callRemote('crawl',[urlTokenizer("http://www.sciencespo.fr"),urlTokenizer("http://medialab.sciences-po.fr")])
d.addCallbacks(printValue, printError)
dl.append(d)
reactor.run()
def printError(error):
status, message = error.value.args
if status == "401":
print message
return
print 'error', error
def shutDown(data):
print "Shutting down reactor..."
reactor.stop()
proxyUnauth = Proxy('http://127.0.0.1:6969/')
dl = []
d = proxyUnauth.callRemote('echo', 'bite me')
d.addCallbacks(printValue, printError)
dl.append(d)
d = proxyUnauth.callRemote('math.add', 3, 5)
d.addCallbacks(printValue, printError)
dl.append(d)
proxyAuth = Proxy('http://*****:*****@127.0.0.1:6969/')
d = proxyAuth.callRemote('echo', 'bite me')
d.addCallbacks(printValue, printError)
dl.append(d)
def query(cls, ip, port, action, *args):
daemon = Proxy('http://%s:%d/' % (ip,port))
return daemon.callRemote(action, *args)
from txjsonrpc.web.jsonrpc import Proxy
import sys
def printValue(value):
print "Result: %s" % str(value)
def printError(error):
print ' !! ERROR: ', error
def shutDown(data):
print "Shutting down reactor..."
reactor.stop()
proxy = Proxy("http://127.0.0.1:8080/")
if len(sys.argv) > 2 and sys.argv[2] == "array":
print sys.argv[1], [a for a in sys.argv[3:]]
d = proxy.callRemote(sys.argv[1], [a for a in sys.argv[3:]])
else:
print sys.argv[1], sys.argv[2:]
d = proxy.callRemote(sys.argv[1], *sys.argv[2:])
d.addCallback(printValue).addErrback(printError)
d.addCallback(shutDown)
reactor.run()
# usage :
# python test_jsonrpc.py echo coucou
def __init__(self, address):
self.proxy = Proxy(address)
total = 0
for v in r.get_value():
var = v.get_value()
print str(var)
def print_error(error):
print 'error', error
def shut_down(data):
reactor.stop()
bm_daemon = Proxy('http://127.0.0.1:' + str(DAEMON_PORT) + '/')
if len(sys.argv) < 2:
print "usage: daemonclient.py [operation] [params]"
print "operations:"
print "========================="
print "start: installs a composition"
print "read: reads a set of variables from a block"
print "stop: uninstalls a composition"
os._exit(1)
op = sys.argv[1]
if op == "start":
if len(sys.argv) < 3:
print "usage: daemonclient.py start [composition]"
if not ok:
log.msg('invalid server cert: %s' % x509.get_subject(),
logLevel=logging.ERROR)
return False
else:
log.msg('good server cert: %s' % x509.get_subject(),
logLevel=logging.INFO)
return True
class AltCtxFactory(ssl.ClientContextFactory):
def getContext(self):
#self.method = SSL.SSLv23_METHOD
ctx = ssl.ClientContextFactory.getContext(self)
ctx.set_verify(SSL.VERIFY_PEER, verifyCallback)
ctx.load_verify_locations("cacert.pem")
#ctx.use_certificate_file('keys/client.crt')
#ctx.use_privatekey_file('keys/client.key')
return ctx
import sys
log.startLogging(sys.stdout)
#proxy = Proxy('https://127.0.0.1:7443/', ssl_ctx_factory=AltCtxFactory)
proxy = Proxy('https://127.0.0.2:7443/', ssl_ctx_factory=AltCtxFactory)
d = proxy.callRemote('add', 3, 5)
d.addCallback(printValue).addErrback(printError).addBoth(shutDown)
reactor.run()
def setUp(self):
self.NODE_PORT = 7080
self.REG_PORT = 7090
self.daemon = Proxy('http://127.0.0.1:%d/' % self.REG_PORT)
self.PORTS = range(5050,5058)
from pymongo import MongoClient
from traceback import print_stack
from twisted.internet import reactor, defer
from txjsonrpc.web.jsonrpc import Proxy
daysback = 7
if len(sys.argv) > 1:
try:
daysback = int(sys.argv[1])
except:
print >> sys.stderr, "ERROR: argument must be an integer (number of days back)"
exit(1)
dayms = 1000 * 60 * 60 * 24
delay = dayms * daysback
proxy = Proxy(environ['HYPHE_API_URL'])
curcorpus = None
@defer.inlineCallbacks
def handleList(res):
if res['code'] == 'fail':
defer.returnValue(printError(res['message']))
destroyed = []
for cid, corpus in res['result'].items():
curcorpus = cid
since = time() * 1000 - corpus['last_activity']
if since > delay:
print "REMOVING old corpus:", cid, corpus['last_activity'], int(since/dayms), "days old"
res = yield proxy.callRemote('start_corpus', cid, environ['HYPHE_ADMIN_PASSWORD'] if corpus['password'] else '')
if res['code'] == 'fail':
print >> sys.stderr, "WARNING: could not start old corpus %s: %s" % (cid, res['message'])
# here we use certificates from txjsonrpc/test/certs/ directory
self.ca_cert_file = certs.ca_cert_file()
self.cert_file = certs.cert_file('pyclient')
self.key_file = certs.key_file('pyclient')
def getContext(self):
ctx = ssl.ClientContextFactory.getContext(self)
ctx.set_verify(SSL.VERIFY_PEER, server_cert_verify_callback)
ctx.set_verify_depth(10)
ctx.load_verify_locations(self.ca_cert_file)
ctx.use_certificate_file(self.cert_file)
ctx.use_privatekey_file(self.key_file)
return ctx
# ------------------------------------------------------------
import sys
log.startLogging(sys.stdout)
if len(sys.argv) > 1:
port = int(sys.argv[1])
else:
port = 7443
proxy = Proxy('https://localhost:%d/' % port, ssl_ctx_factory=AltCtxFactory)
d = proxy.callRemote('add', 3, 5)
d.addCallback(printValue).addErrback(printError).addBoth(shutDown)
reactor.run()
def setUp(self):
self.NODE_PORT = 7080
self.daemon = Proxy('http://127.0.0.1:%d/' % self.NODE_PORT)
self.comp = 'step1'
auto_convert_integers = False
if sys.argv[1] == "inline":
inline = True
startargs = 3
elif sys.argv[1] == "json":
inline = "json"
startargs = 3
else:
inline = False
startargs = 2
print('inline',inline,'startargs',startargs)
proxy = Proxy('http://127.0.0.1:6978')
command = sys.argv[startargs - 1]
args = []
is_array = False
for a in sys.argv[startargs:]:
display_message(a)
if a == "array":
print('isarray')
is_array = True
else:
print('else')
if is_array:
print('isarray')
if (a.startswith('[') and a.endswith(']')) or (a.startswith('{') and a.endswith('}')):
print('startswith')
args.append(eval(a))
def _get_random_server(self):
return Proxy(random.choice(self.servers))
