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')