def __init__(self,
host,
port,
privkey,
nonce_update_interval=5.0,
nonce_offset=0):
endpoint = 'http://{}:{}'.format(host, port)
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(pool_maxsize=50)
session.mount(endpoint, adapter)
self.transport = HttpPostClientTransport(
endpoint,
post_method=session.post,
headers={'content-type': 'application/json'},
)
self.port = port
self.privkey = privkey
self.protocol = JSONRPCProtocol()
self.sender = privatekey_to_address(privkey)
# Needs to be initialized to None in the beginning since JSONRPCClient
# gets constructed before the RaidenService Object.
self.stop_event = None
self.nonce_last_update = 0
self.nonce_current_value = None
self.nonce_lock = Semaphore()
self.nonce_update_interval = nonce_update_interval
self.nonce_offset = nonce_offset
def __init__(self,
host,
port,
privkey,
nonce_update_interval=5.0,
nonce_offset=0):
endpoint = 'http://{}:{}'.format(host, port)
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(pool_maxsize=50)
session.mount(endpoint, adapter)
self.transport = HttpPostClientTransport(
endpoint,
post_method=session.post,
headers={'content-type': 'application/json'},
)
self.port = port
self.privkey = privkey
self.protocol = JSONRPCProtocol()
self.sender = privatekey_to_address(privkey)
self.nonce_last_update = 0
self.nonce_current_value = None
self.nonce_lock = Semaphore()
self.nonce_update_interval = nonce_update_interval
self.nonce_offset = nonce_offset
def authenticate(self):
"""
Performs authentication actions
Patches `tinyrpc` to remove minor incompatibilities due to JSON-RPC
protocol version differences. This is performed once.
Initializes the RPCClient and RPCProxy instances that
are used to make the requests to Lime.
:return: None
"""
logger.info("Authenticating LimeAPI client")
if not LimeAPI._rpc_protocol_patched:
LimeAPI.patch_json_rpc_protocol()
LimeAPI._rpc_protocol_patched = True
self.rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport(endpoint=self.remote_api_url,
headers=self.headers),
)
self.rpc_proxy = self.rpc_client.get_proxy()
self.session_key = self.rpc_proxy.get_session_key(
username=self.username, password=self.password)
if not self._validate_session_key():
raise Exception(f"Failed to validate session key: url={self.url} "
f"session_key={self.session_key}")
self._authenticated = True
logger.info(f"Acquired session key: {self.session_key}")
def __init__(self, ip_hostname='pulsestreamer'):
print("Connect to Pulse Streamer via JSON-RPC.")
print("IP / Hostname:", ip_hostname)
url = 'http://' + ip_hostname + ':8050/json-rpc'
try:
self.INFINITE = -1
self.CONSTANT_ZERO = (0, 0, 0, 0)
if sys.version_info.major > 2:
client = RPCClient(url)
else:
client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport(url))
self.proxy = client.get_proxy()
try:
self.proxy.getSerial()
except:
try:
self.proxy.isRunning()
print(
"Pulse Streamer class not compatible with current firmware. Please update your firmware."
)
sys.exit(1)
except:
print("No Pulse Streamer found at IP/Host-address: " +
ip_hostname)
sys.exit(1)
except:
print("No Pulse Streamer found at IP/Host-address: " + ip_hostname)
sys.exit(1)
def __init__(self, node_url=None):
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport(
node_url or os.getenv("RADIX_NODE_URL") or DEFAULT_NODE_URL
),
)
self._rpc_proxy = rpc_client.get_proxy(prefix=RPC_METHOD_PREFIX)
def __init__(self, obj, one_way=False):
url = obj.env['device_manager.settings']._get_param(
'mqtt_rpc_bridge_url')
logger.debug('HTTP bridge url {}'.format(url))
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport(url)
)
self.proxy = rpc_client.get_proxy(one_way=one_way)
def sessioned_client():
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(pool_maxsize=100)
session.mount('http://', adapter)
client = HttpPostClientTransport(
'http://%s:%d' % TEST_SERVER_ADDR,
post_method=session.post
)
return client
def __init__(self,
host="127.0.0.1",
port=4000,
print_communication=True,
privkey=None,
sender=None):
super(JSONRPCClient, self).__init__(port, print_communication, privkey,
sender)
self.transport = HttpPostClientTransport("http://{}:{}".format(
host, port))
def __init__(self,
port=4000,
print_communication=True,
privkey=None,
sender=None):
"specify privkey for local signing"
self.transport = HttpPostClientTransport(
'http://127.0.0.1:{}'.format(port))
self.print_communication = print_communication
self.privkey = privkey
self._sender = sender
def __init__(self,
host: str,
port: int,
privkey: bytes,
gasprice: int = None,
nonce_update_interval: float = 5.0,
nonce_offset: int = 0):
if privkey is None or len(privkey) != 32:
raise ValueError('Invalid private key')
endpoint = 'http://{}:{}'.format(host, port)
self.session = requests.Session()
adapter = requests.adapters.HTTPAdapter(pool_maxsize=50)
self.session.mount(endpoint, adapter)
self.transport = HttpPostClientTransport(
endpoint,
post_method=self.session.post,
headers={'content-type': 'application/json'},
)
self.port = port
self.privkey = privkey
self.protocol = JSONRPCProtocol()
self.sender = privatekey_to_address(privkey)
# Needs to be initialized to None in the beginning since JSONRPCClient
# gets constructed before the RaidenService Object.
self.stop_event = None
self.nonce_last_update = 0
self.nonce_available_value = None
self.nonce_lock = Semaphore()
self.nonce_update_interval = nonce_update_interval
self.nonce_offset = nonce_offset
self.given_gas_price = gasprice
cache = cachetools.TTLCache(
maxsize=1,
ttl=RPC_CACHE_TTL,
)
cache_wrapper = cachetools.cached(cache=cache)
self.gaslimit = cache_wrapper(self._gaslimit)
cache = cachetools.TTLCache(
maxsize=1,
ttl=RPC_CACHE_TTL,
)
cache_wrapper = cachetools.cached(cache=cache)
self.gasprice = cache_wrapper(self._gasprice)
def setUpClass(cls):
cls.context = zmq.Context()
cls.subscriber = cls.context.socket(zmq.SUB)
cls.remote_server = None
cls.subscriber.connect("tcp://%s:5500" % HOST)
cls.subscriber.setsockopt(zmq.SUBSCRIBE, "DEFAULT")
cls.subscriber.setsockopt(zmq.SUBSCRIBE, "SUB_KEY")
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport("http://%s:5501" % HOST))
cls.remote_server = rpc_client.get_proxy()
# Cross-test variables
cls.coflow_id = ""
def __init__(self, address='192.168.1.100'):
if (toolbox.validate_ip(address)):
self.ip = address
self.url = 'http://' + self.ip + ':8050/json-rpc'
try:
self.client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport(self.url))
except:
print('Error: cannot create RPC client!')
try:
self.ps = self.client.get_proxy()
except:
print('Error: cannot create proxy connection!')
else:
print("IP address not valid!")
def __init__(self, ip_hostname='pulsestreamer'):
print("Connect to Pulse Streamer via JSON-RPC.")
print("IP / Hostname:", ip_hostname)
self.ip_address = ip_hostname
url = 'http://' + ip_hostname + ':8050/json-rpc'
try:
client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport(url, timeout=20))
self.proxy = client.get_proxy()
try:
self.proxy.getSerial()
except:
try:
self.proxy.isRunning()
assert False, "Pulse Streamer class not compatible with current firmware. Please update your firmware." \
"For detailed information visit https://www.swabianinstruments.com/pulse-streamer-8-2-firmware/ " \
"or contact [email protected]"
except AssertionError:
raise
except:
assert False, "No Pulse Streamer found at IP/Host-address: " + ip_hostname
except AssertionError:
raise
except:
assert False, "No Pulse Streamer found at IP/Host-address: " + ip_hostname
firmware_version = self.proxy.getFirmwareVersion()
self.__version_1_1_or_higher = True if _compare_version_number(
firmware_version, '1.1.0') >= 0 else False
print("Pulse Streamer 8/2 firmware: v" + firmware_version)
print("Client software: v" + __CLIENT_VERSION__)
if (_compare_version_number(firmware_version) >= 0):
print(
"The Pulse Streamer 8/2 firmware is more up to date than your client software. We recommend to update your client software."
)
print(
"For detailed information visit https://www.swabianinstruments.com/support/downloads/ or contact [email protected]"
)
elif (_compare_version_number(
'.'.join(__CLIENT_VERSION__.split('.')[0:2] + ['0']),
'.'.join(firmware_version.split('.')[0:2] + ['0'])) > 0):
print(
"Your client software is more up to date than the Pulse Streamer 8/2 firmware. We recommend to update the firmware of your Pulse Streamer 8/2."
)
print(
"For detailed information visit https://www.swabianinstruments.com/support/downloads/ or contact [email protected]"
)
def __init__(self, args):
cmd2.Cmd.__init__(self)
self.prompt = "\n\033[1;33m# \033[0m"
self.args = args
uri = ''.join(
["http://", args['--host'], ":", args['--port'], "/jsonrpc"])
rpc_client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(uri))
self.xbmc = rpc_client
self.input = namespaces.Input(self.xbmc)
self.gui = namespaces.GUI(self.xbmc)
self.jsonrpc = namespaces.JSONRPC(self.xbmc)
self.video_library = namespaces.VideoLibrary(self.xbmc)
self.player = namespaces.Player(self.xbmc)
def __init__(self,
host='127.0.0.1',
port=4000,
print_communication=True,
privkey=None,
sender=None,
use_ssl=False,
transport=None):
"specify privkey for local signing"
if transport is None:
self.transport = HttpPostClientTransport(
'{}://{}:{}'.format('https' if use_ssl else 'http', host,
port),
headers={'content-type': 'application/json'})
else:
self.transport = transport
self.print_communication = print_communication
self.privkey = privkey
self._sender = sender
self.port = port
def __init__(self, zmq_context, source, destination, n_bytes):
threading.Thread.__init__(self)
self.key = "SENDER%i" % Sender.count
Sender.count += 1
self.subscriber = zmq_context.socket(zmq.SUB)
self.subscriber.connect("tcp://%s:5500" % HOST)
self.subscriber.setsockopt(zmq.SUBSCRIBE, self.key)
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport("http://%s:5501" % HOST))
self.remote_server = rpc_client.get_proxy()
self.source = source
self.destination = destination
self.n_bytes = n_bytes
self.result = ""
def __init__(self, host='127.0.0.1', port=4000, print_communication=True,
privkey=None, sender=None, use_ssl=False, transport=None):
"""
Args:
host (str): host address to connect to.
port (int): port number to connect to.
print_communication (bool): True to print the rpc communication.
privkey: specify privkey for local signing
sender (address): the sender address, computed from privkey if provided.
use_ssl (bool): Use https instead of http.
transport: Tiny rpc transport instance.
"""
if transport is None:
self.transport = HttpPostClientTransport('{}://{}:{}'.format(
'https' if use_ssl else 'http', host, port), headers={'content-type': 'application/json'})
else:
self.transport = transport
self.print_communication = print_communication
self.privkey = privkey
self._sender = sender
self.port = port
* we use the tinyrpc python package that allows us to represent the timetagger webserver
as a python class and will hide all JSON-RPC details from us.
* The methods of this 'proxy class' are equivalent to the JSON-RPC interface
"""
#from jsonrpc import ServiceProxy
#timetagger = ServiceProxy('http://localhost:8080/json-rpc')
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport('http://localhost:8080/json-rpc'))
# create the proxy class
timetagger = rpc_client.get_proxy()
timetagger.getSystemInfo()
timetagger.scanDevices()
res = timetagger.getDeviceList()
dev_id = res[0]['id'] # dev_id = '12520004J3' # FPGA serial number
res = timetagger.getModuleList(device=dev_id)
mod_id = res[0][
'id'] # mod_id = 'ID-000001' # module created in web application beforehand
timetagger.getDeviceInfo(device=dev_id)
def __init__(self, port=4000, print_communication=True):
self.transport = HttpPostClientTransport(
'http://127.0.0.1:{}'.format(port))
self.print_communication = print_communication
import time
from threading import Thread
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport('http://192.168.100.174:10090/'))
remote_server = rpc_client.get_proxy()
topicName = 'test_topic'
topicName = 'display_command'
k = 0
def queryTopics():
while True:
time.sleep(0.05)
result = remote_server.ROSPublishTopics([])
print "Server answered:"
print result
prgThread = Thread(target=queryTopics)
prgThread.setDaemon(True)
prgThread.start()
def non_sessioned_client():
client = HttpPostClientTransport('http://%s:%d' % TEST_SERVER_ADDR)
return client
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport('http://localhost:5000/v1/jsonrpc')
)
rpc_server = rpc_client.get_proxy()
print "pinging..."
pong = rpc_server.ping()
print "ping response: " + pong
resp = rpc_server.hello("Ashutosh")
print "hello world response: " + resp
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
import time
import sys
rpc_client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport('http://192.168.1.100:8080/'))
remote_server = rpc_client.get_proxy()
try:
vhf_data_rate = None
uhf_data_rate = None
sat_comm_data_rate = None
while True:
time.sleep(2)
vhf_data_rate_json = remote_server.get_vhf_data_rate()
vhf_data_rate = vhf_data_rate_json['vhf_rate']
uhf_data_rate_json = remote_server.get_uhf_data_rate()
uhf_data_rate = uhf_data_rate_json['uhf_rate']
sat_comm_data_rate_json = remote_server.get_sat_comm_data_rate()
sat_comm_data_rate = sat_comm_data_rate_json['satcomm_rate']
print("\n\n\nCurrent VHF data rate is: ", vhf_data_rate)
print("\n\n\nCurrent UHF data rate is: ", uhf_data_rate)
print("\n\n\nCurrent SatComm data rate is: ", sat_comm_data_rate)
except KeyboardInterrupt:
#!/usr/bin/python
#
# pip install tinyrpc
#
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport('http://localhost:8080/'))
local = rpc_client.get_proxy()
s = ' This is a message '
stripped = local.strip(str=s)
assert stripped == s.strip()
print 'rpc ok'
import sys
sys.exit(0)
'''
refer : https://github.com/mbr/tinyrpc/tree/master/examples
import gevent
import tinyrpc
import gevent-websocket
'''
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport('http://127.0.0.1:5000/'))
remote_server = rpc_client.get_proxy()
# call a method called 'reverse_string' with a single string argument
result = remote_server.reverse_string('Hello, World!')
print("Server answered: ", result)
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(JSONRPCProtocol(),
HttpPostClientTransport('http://127.0.0.1:10090/'))
remote_server = rpc_client.get_proxy()
# call a method called 'reverse_string' with a single string argument
msgs = [{
"topic": "tA",
"params": {}
}, {
"topic": "huh",
"params": {}
}, {
"topic": "/tf",
"params": {
"frame_id": "World",
"child_frame_id": "Robot",
"x": "10.0",
"y": "2",
"z": "3",
"qx": "0.0",
"qy": "0.7",
"qz": "-0.7",
"qw": "0.01"
}
}, {
"topic": "/tf",
# -*- coding: utf-8 -*-
"""Example RPC client for controlling a wotabag.
Requires tinrypc[httpclient] (https://github.com/mbr/tinyrpc).
"""
import time
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.http import HttpPostClientTransport
from tinyrpc import RPCClient
rpc_client = RPCClient(
JSONRPCProtocol(),
HttpPostClientTransport('http://raspberrypi.local:60715/'))
server = rpc_client.get_proxy(prefix='wotabag.')
# Retrieve server status
result = server.get_status()
print(result)
# Retrieve server playlist
result = server.get_playlist()
print(result)
# Test LED patterns
server.test_pattern()
# Start playback
