def __init__(self, rpcuser=None, rpcpassword=None, host=None, port=None):
"""Connects to node using credentials given
Parameters
----------
rpcuser : str
as defined in bitcoin.conf
rpcpassword : str
as defined in bitcoin.conf
host : str, optional
host where the Bitcoin node resides; defaults to 127.0.0.1
port : int, optional
port to connect to; uses default ports according to network
Raises
------
ValueError
if rpcuser and/or rpcpassword are not specified
"""
if not rpcuser or not rpcpassword:
raise ValueError('rpcuser or rpcpassword is missing')
if not host:
host = '127.0.0.1'
if not port:
port = NETWORK_DEFAULT_PORTS[get_network()]
self.proxy = Server("http://{}:{}".format(host, port),
auth=(rpcuser, rpcpassword))
def main():
parser = argparse.ArgumentParser(description='DefiChain Exporter')
parser.add_argument('--username', help='rpc username')
parser.add_argument('--password', help='rpc password')
parser.add_argument('--port', help='exporter port (default 8000)', default=8000)
parser.add_argument('--masternode', help='masternode host (default http://localhost:8554)', default='http://localhost:8554')
args = parser.parse_args()
start_http_server(args.port)
server = Server(args.masternode, auth=(args.username, args.password))
masternode_minting_functions = {
"currentblockweight": { "type": "gauge", "obj" : Gauge('masternode__minting_current_blockweight', 'Current Blockweight')},
"currentblocktx": { "type": "gauge", "obj" : Gauge('masternode_minting_current_blocktx', 'Current Blocktx')},
"difficulty": { "type": "gauge", "obj" : Gauge('masternode_minting_difficulty', 'Difficulty')},
'isoperator': { "type": "enum", "obj" : Enum('masternode_minting_isoperator', 'Is Operator', states = ["True", "False"])},
'masternodestate': { "type": "enum", "obj" : Enum('masternode_minting_masternodestate', 'Masternode state', states = ["ENABLED", "PRE_ENABLED", "PRE_RESIGNED", "RESIGNED", "PRE_BANNED", "BANNED"])},
"mintedblocks": { "type": "gauge", "obj" : Gauge('masternode_minting_mintedblocks', 'Minted blocks')}
}
while True:
process_masternode_minting(server, masternode_minting_functions)
time.sleep(random.random())
def main(port, force=False):
server = Server(f'http://127.0.0.1:{port}')
last_block = None
while True:
try:
info = server.getblockchaininfo()
trace(info)
if info['block'] != last_block:
needs_solve = (last_block is not None) or force
trace('needs_solve?', needs_solve)
if needs_solve:
block = server.getblockinfo(info['block'])
sol = solve(block)
trace('sol:', sol)
if sol:
trace('submit')
r = server.submit(sol['block'], sol['task_sol_fn'],
sol['puzzle_sol_fn'])
trace(r)
last_block = info['block']
except:
trace(traceback.format_exc())
pass
trace('idle')
time.sleep(random.randint(15, 25))
def get_session_key(self):
self.server = Server(self.limesurvey_rpc)
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key,
dict) else self.session_key
except TransportError:
self.session_key = None
def test_forbid_private_methods(self):
"""Test that we can't call private class methods (those starting with '_')"""
s = Server('http://host-doesnt-exist')
with self.assertRaises(AttributeError):
s._foo()
# nested private method call
with self.assertRaises(AttributeError):
s.foo.bar._baz()
def setUp(self):
self.server = Server(
'http://survey.numec.prp.usp.br/index.php/admin/remotecontrol')
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
# Checks if connected in the LimeSurvey with the settings.py credentials
self.assertNotIsInstance(self.session_key, dict)
def main():
# bionet nodes have a json_rpc endpoint at /rpc
bionet = Server('http://localhost:8000/rpc')
try:
res = bionet.searchVirtuals('t')
print "foo() said: %s" % res
except ProtocolError as err:
print("while calling .searchVirtuals(): %s" % err.message)
def main():
api = Server("http://127.0.0.1:9996/api")
with codecs.open("web/src/defaultSentence.txt", encoding="utf-8") as f:
sentence = f.read().strip()
with codecs.open("web/src/defaultTree.txt", "w", encoding="utf-8") as f:
f.write(api.phrase_parse(sentence))
with codecs.open("web/src/defaultEDS.txt", "w", encoding="utf-8") as f:
f.write(api.hrg_parse(sentence))
def get_session_key(self):
self.server = Server(settings.LIMESURVEY['URL_API'] +
'/index.php/admin/remotecontrol')
try:
self.session_key = self.server.get_session_key(
settings.LIMESURVEY['USER'], settings.LIMESURVEY['PASSWORD'])
self.session_key = None if isinstance(self.session_key, dict) \
else self.session_key
except TransportError:
self.session_key = None
def test_headers_passthrough(self):
"""Test that we correctly send RFC-defined headers and merge them with user defined ones"""
def callback(request):
expected_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json-rpc',
'X-TestCustomHeader': '1'
}
self.assertTrue(set(expected_headers.items()).issubset(set(request.headers.items())))
return 200, {}, u'{"jsonrpc": "2.0", "result": true, "id": 1}'
responses.add_callback(
responses.POST, 'http://mock/xmlrpc', content_type='application/json', callback=callback,
)
s = Server('http://mock/xmlrpc', headers={'X-TestCustomHeader': '1'})
s.foo()
def main(port):
server = Server(f'http://127.0.0.1:{port}')
last_block = None
while True:
info = server.getblockchaininfo()
trace(info)
if info['block'] != last_block:
last_block = info['block']
notify_user('New block ' + str(last_block),
title='ICFPC',
sound='Basso')
time.sleep(random.randint(15, 25))
def main():
bionet = Server('http://localhost:3000/rpc')
res = bionet.foo('foo')
print "no stream: %s" % res
res = bionet.bar()
print "return stream: %s" % res
res = bionet.baz('a')
print "callback stream: %s" % res
try:
res = bionet.fail()
except ProtocolError as err:
print("got error: %s" % err.message)
print("just the error message: %s" %
err.server_data['error']['message'])
try:
res = bionet.secret()
except ProtocolError as err:
print("while calling .secret(): %s" % err.message)
res = bionet.login('foo', 'bar')
# note: your probably won't ever need to use this token manually
print "logged in and got token: %s" % res
res = bionet.secret()
print "secret: %s" % res
try:
res = bionet.admin_secret()
except ProtocolError as err:
print("while calling .admin_secret(): %s" % err.message)
def __init__(self, zcashd_url):
self.solver = Solver()
self.server = Server(zcashd_url)
from pprint import pprint
from jsonrpc_requests import Server
server = Server('http://localhost:37128')
server.getstatus()
server.createwallet("test1", "samkorn")
# Throws "Response without a result field"
server.selectwallet("test1")
server.getwalletinfo("test1")
server.listunspentcoins()
server.getnewaddress("test receive")
server.send()
{
"payments": [{
"sendto": "tb1qgvnht40a08gumw32kp05hs8mny954hp2snhxcz",
"amount": 15000,
"label": "David"
}, {
"sendto": "tb1qpyhfrpys6skr2mmnc35p3dp7zlv9ew4k0gn7qm",
"amount": 86200,
"label": "Michael"
}],
"coins": [{
"transactionid":
"ab83d9d0b2a9873b8ab0dc48b618098f3e7fbd807e27a10f789e9bc330ca89f7",
def __init__(self, host, port, user, password, cache=None):
self._rpc_server = Server('http://%s:%s' % (host, port),
auth=(user, password))
self._cache = cache if cache else LocalCache()
#!/usr/bin/python
from jsonrpc_requests import Server
rpc = Server('http://localhost:5555')
print(rpc.object.slot())
print(rpc.object.slotWithParams("one", False, 10))
print(rpc.object.slotWithParamsAndReturnValue("kostya"))
from jsonrpc_requests import Server
fusion = Server("http://EMEA-DCRS-FM-48X-1/jsonrpc")
fusion.login(username="******", password="******")
#print (fusion.get_hostname())
#print (fusion.get_startup_config("patch"))
#print (fusion.get_messages())
pl = fusion.get_ports("A1", "A2", "A3")
print(pl[0])
for i in pl:
for k in i.keys():
if (i[k] != ''):
if (k != 'name'):
print(" {:<16s} : {:2s} ".format(k, str(i[k])))
else:
print(i[k])
print('\n')
from jsonrpc_requests import Server
from Savoir import Savoir
from requests import post
from threading import Thread
import time
import json
from conf import *
if __name__ == "__main__":
ltc = Server("http://127.0.0.1:"+bport, auth=(buser,\
bpassword))
versum = Savoir(muser, \
mpassword, \
"localhost", mport, \
mchainname)
url = publicserver + "/ltc/"
def refill_raddresses():
"""
Ensures that always deposit addresses are available in the Database
"""
while True:
try:
data = json.dumps({"password": publicserverpassword})
r = post(url + "len/raddress", data).text
if int(r) < 100:
raddress = ltc.getnewaddress()
data = json.dumps({"password":publicserverpassword,\
"raddress": raddress})
r = post(url + "set/raddress", data).text
def _json_rpc_call(url, method, *args, **kwargs):
return getattr(Server(url), method).__call__(*args, **kwargs)
def test_exception_passthrough(self):
with self.assertRaises(TransportError) as transport_error:
s = Server('http://host-doesnt-exist')
s.foo()
self.assertEqual(transport_error.exception.args[0], "Error calling method 'foo'")
self.assertIsInstance(transport_error.exception.args[1], requests.exceptions.RequestException)
else:
DatabaseRestrictions.store_address(
DatabaseRestrictions.new_entry(address))
if telegram_address:
DatabaseRestrictions.update_request(telegram_address)
else:
DatabaseRestrictions.store_address(
DatabaseRestrictions.new_telegram_entry(
str(update.message.from_user.id)))
update.message.reply_text(MESSAGE_SUCCESS)
except:
traceback.print_exc()
update.message.reply_text(MESSAGE_ERROR)
node = Server(FAUCET_CLI)
update_id = None
bot = telegram.Bot(BOT_TOKEN)
try:
update_id = bot.get_updates()[0].update_id
except IndexError:
update_id = None
while True:
try:
work(bot)
except NetworkError:
sleep(1)
except Unauthorized:
update_id += 1
def __init__(self, rpc_url, rpc_user, rpc_password):
headers = {'Authorization': self.authenticate_str(rpc_user, rpc_password)}
self.connection = Server(rpc_url, headers=headers)
info = self.connection.getinfo()
logger.debug('Connected to XPd (version: {0}) successfully'.format(info['version']))
from jsonrpc_requests import Server
bitcoind = Server('http://chains.bo:8332', auth=('btcrpc', 'btc'))
address = bitcoind.getnewaddress()
privkey = bitcoind.dumpprivkey(address)
print(address)
print(privkey)
from jsonrpc_requests import Server
eth = Server('http://eth.xsika.cz:8545')
print(eth.eth_blockNumber())
print(eth.personal_newAccount(''))
parser_s = subparsers.add_parser('submit')
parser_s.add_argument('block', default=None, help="block to submit for")
parser_s.add_argument('task_sol_path',
default=None,
help=".sol file for block task")
parser_s.add_argument('puzzle_sol_path',
default=None,
help=".desc file for block puzzle")
args = parser.parse_args()
try:
args.port = int(args.port)
except ValueError:
parser.error('Port must be an integer.')
server = Server(f'http://{args.bind}:{args.port}')
# Handle getblockinfo
if args.subcmd == 'getblockinfo':
bi = None
if args.block is None:
bi = server.getblockinfo()
else:
# Allow commands like `./lambda-cli.py getblockinfo block`
# i.e. with block taken as item rather than item
if not args.block.isdecimal():
args.subitem = args.item
args.item = args.block
args.block = None
bi = server.getblockinfo(
) if args.block is None else server.getblockinfo(args.block)
def __init__(self, rpcUrl, rpcUser, rpcPass):
self.srv = Server(rpcUrl, auth=(rpcUser, rpcPass))
def setUp(self):
random.randint = Mock(return_value=1)
self.server = Server('http://mock/xmlrpc')
