class ElectrumGui: def __init__(self, config, network): self.network = network self.config = config storage = WalletStorage(self.config.get_wallet_path()) if not storage.file_exists: raise BaseException("Wallet not found") self.wallet = Wallet(storage) self.cmd_runner = Commands(self.config, self.wallet, self.network) host = config.get('rpchost', 'localhost') port = config.get('rpcport', 7777) self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler) self.server.socket.settimeout(1) for cmdname in known_commands: self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname) def main(self, url): self.wallet.start_threads(self.network) while True: try: self.server.handle_request() except socket.timeout: continue except: break self.wallet.stop_threads()
class RPCApi(): functions = [] def __init__(self, config): self.config = config self.server = SimpleJSONRPCServer( (self.config['rpc_host'], self.config['rpc_port'])) self.server.timeout = self.config[ 'rpc_timeout'] if "rpc_timeout" in config else 1 self.server.logRequests = self.config[ 'verbose'] if "verbose" in config else False self.register_function(self.list_functions, "list_functions") def register_functions(self, **kwargs): """Registers functions with the server.""" for function_name in kwargs: function = kwargs[function_name] self.register_function(function, function_name) def register_function(self, function, function_name): """Registers a single function with the server.""" self.server.register_function(function, function_name) self.functions.append(function_name) def list_functions(self): """An externally accessible function returning all the registered function names""" return list(set(self.functions)) def poll(self): """Serves one request from the waiting requests and returns""" self.server.handle_request() def run(self): """Blocks execution and runs the server till the program shutdown""" self.server.serve_forever() def start_thread(self): """Starts self.run() in a separate thread""" self.thread = threading.Thread(target=self.run) self.thread.daemon = True self.thread.start()
# create watching_only wallet storage = electrum.WalletStorage(c) if not storage.file_exists: print "creating wallet file" wallet = electrum.wallet.Wallet.from_xpub(xpub, storage) else: wallet = electrum.wallet.Wallet(storage) wallet.synchronize = lambda: None # prevent address creation by the wallet wallet.start_threads(network) network.register_callback('updated', on_wallet_update) threading.Thread(target=db_thread, args=()).start() out_queue = Queue.Queue() # server thread from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer server = SimpleJSONRPCServer(( my_host, my_port)) server.register_function(process_request, 'request') server.register_function(do_dump, 'dump') server.register_function(getrequest, 'getrequest') server.register_function(do_stop, 'stop') server.socket.settimeout(1) while not stopping: try: server.handle_request() except socket.timeout: continue
class Daemon(DaemonThread): def __init__(self, config, network, gui=None): DaemonThread.__init__(self) self.config = config self.network = network self.gui = gui self.wallets = {} if gui is None: self.wallet = self.load_wallet(config) else: self.wallet = None self.cmd_runner = Commands(self.config, self.wallet, self.network) host = config.get('rpchost', 'localhost') port = config.get('rpcport', 0) self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler, logRequests=False) with open(lockfile(config), 'w') as f: f.write(repr(self.server.socket.getsockname())) self.server.timeout = 0.1 for cmdname in known_commands: self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname) self.server.register_function(self.run_cmdline, 'run_cmdline') self.server.register_function(self.ping, 'ping') self.server.register_function(self.run_daemon, 'daemon') self.server.register_function(self.run_gui, 'gui') def ping(self): return True def run_daemon(self, config): sub = config.get('subcommand') assert sub in ['start', 'stop', 'status'] if sub == 'start': response = "Daemon already running" elif sub == 'status': p = self.network.get_parameters() response = { 'path': self.network.config.path, 'server': p[0], 'blockchain_height': self.network.get_local_height(), 'server_height': self.network.get_server_height(), 'nodes': self.network.get_interfaces(), 'connected': self.network.is_connected(), 'auto_connect': p[4], 'wallets': self.wallets.keys(), } elif sub == 'stop': self.stop() response = "Daemon stopped" return response def run_gui(self, config_options): config = SimpleConfig(config_options) if self.gui: if hasattr(self.gui, 'new_window'): path = config.get_wallet_path() self.gui.new_window(path, config.get('url')) response = "ok" else: response = "error: current GUI does not support multiple windows" else: response = "Error: Electrum is running in daemon mode. Please stop the daemon first." return response def load_wallet(self, config): path = config.get_wallet_path() if path in self.wallets: wallet = self.wallets[path] else: storage = WalletStorage(path) wallet = Wallet(storage) wallet.start_threads(self.network) self.wallets[path] = wallet return wallet def run_cmdline(self, config_options): password = config_options.get('password') config = SimpleConfig(config_options) cmdname = config.get('cmd') cmd = known_commands[cmdname] wallet = self.load_wallet(config) if cmd.requires_wallet else None if wallet: wallet.wait_until_synchronized() # arguments passed to function args = map(lambda x: config.get(x), cmd.params) # decode json arguments args = map(json_decode, args) # options args += map(lambda x: config.get(x), cmd.options) cmd_runner = Commands(config, wallet, self.network) cmd_runner.password = password func = getattr(cmd_runner, cmd.name) result = func(*args) return result def run(self): while self.is_running(): self.server.handle_request() os.unlink(lockfile(self.config)) def stop(self): for k, wallet in self.wallets.items(): wallet.stop_threads() DaemonThread.stop(self)
class Daemon(DaemonThread): def __init__(self, config, network): DaemonThread.__init__(self) self.config = config self.network = network self.wallets = {} self.wallet = self.load_wallet(config.get_wallet_path()) self.cmd_runner = Commands(self.config, self.wallet, self.network) host = config.get('rpchost', 'localhost') port = config.get('rpcport', 0) self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler, logRequests=False) with open(lockfile(config), 'w') as f: f.write(repr(self.server.socket.getsockname())) self.server.timeout = 0.1 for cmdname in known_commands: self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname) self.server.register_function(self.run_cmdline, 'run_cmdline') self.server.register_function(self.ping, 'ping') self.server.register_function(self.run_daemon, 'daemon') def ping(self): return True def run_daemon(self, config): sub = config.get('subcommand') assert sub in ['start', 'stop', 'status'] if sub == 'start': response = "Daemon already running" elif sub == 'status': p = self.network.get_parameters() response = { 'path': self.network.config.path, 'server': p[0], 'blockchain_height': self.network.get_local_height(), 'server_height': self.network.get_server_height(), 'nodes': self.network.get_interfaces(), 'connected': self.network.is_connected(), 'auto_connect': p[3], 'wallets': dict([(k, w.is_up_to_date()) for k, w in self.wallets.items()]), } elif sub == 'stop': self.stop() response = "Daemon stopped" return response def load_wallet(self, path, get_wizard=None): if path in self.wallets: wallet = self.wallets[path] else: storage = WalletStorage(path) if get_wizard: if storage.file_exists: wallet = Wallet(storage) action = wallet.get_action() else: action = 'new' if action: wizard = get_wizard() wallet = wizard.run(self.network, storage) else: wallet.start_threads(self.network) else: wallet = Wallet(storage) # automatically generate wallet for ulord if not storage.file_exists: seed = wallet.make_seed() wallet.add_seed(seed, None) wallet.create_master_keys(None) wallet.create_main_account() wallet.synchronize() wallet.start_threads(self.network) if wallet: self.wallets[path] = wallet return wallet def run_cmdline(self, config_options): config = SimpleConfig(config_options) cmdname = config.get('cmd') cmd = known_commands[cmdname] path = config.get_wallet_path() wallet = self.load_wallet(path) if cmd.requires_wallet else None # arguments passed to function args = map(lambda x: config.get(x), cmd.params) # decode json arguments args = map(json_decode, args) # options args += map(lambda x: config.get(x), cmd.options) cmd_runner = Commands(config, wallet, self.network, password=config_options.get('password'), new_password=config_options.get('new_password')) func = getattr(cmd_runner, cmd.name) result = func(*args) return result def run(self): while self.is_running(): self.server.handle_request() os.unlink(lockfile(self.config)) def stop(self): for k, wallet in self.wallets.items(): wallet.stop_threads() DaemonThread.stop(self)
class Daemon(DaemonThread): def __init__(self, config, network, gui=None): DaemonThread.__init__(self) self.config = config self.network = network self.gui = gui self.wallets = {} if gui is None: self.wallet = self.load_wallet(config) else: self.wallet = None self.cmd_runner = Commands(self.config, self.wallet, self.network) host = config.get('rpchost', 'localhost') port = config.get('rpcport', 0) self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler, logRequests=False) with open(lockfile(config), 'w') as f: f.write(repr(self.server.socket.getsockname())) self.server.timeout = 0.1 for cmdname in known_commands: self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname) self.server.register_function(self.run_cmdline, 'run_cmdline') self.server.register_function(self.ping, 'ping') self.server.register_function(self.run_daemon, 'daemon') self.server.register_function(self.run_gui, 'gui') def ping(self): return True def run_daemon(self, config): sub = config.get('subcommand') assert sub in ['start', 'stop', 'status'] if sub == 'start': response = "Daemon already running" elif sub == 'status': p = self.network.get_parameters() response = { 'path': self.network.config.path, 'server': p[0], 'blockchain_height': self.network.get_local_height(), 'server_height': self.network.get_server_height(), 'nodes': self.network.get_interfaces(), 'connected': self.network.is_connected(), 'auto_connect': p[4], 'wallets': dict([ (k, w.is_up_to_date()) for k, w in self.wallets.items()]), } elif sub == 'stop': self.stop() response = "Daemon stopped" return response def run_gui(self, config_options): config = SimpleConfig(config_options) if self.gui: if hasattr(self.gui, 'new_window'): path = config.get_wallet_path() self.gui.new_window(path, config.get('url')) response = "ok" else: response = "error: current GUI does not support multiple windows" else: response = "Error: Electrum is running in daemon mode. Please stop the daemon first." return response def load_wallet(self, config): path = config.get_wallet_path() if path in self.wallets: wallet = self.wallets[path] else: storage = WalletStorage(path) wallet = Wallet(storage) wallet.start_threads(self.network) self.wallets[path] = wallet return wallet def run_cmdline(self, config_options): password = config_options.get('password') config = SimpleConfig(config_options) cmdname = config.get('cmd') cmd = known_commands[cmdname] wallet = self.load_wallet(config) if cmd.requires_wallet else None # arguments passed to function args = map(lambda x: config.get(x), cmd.params) # decode json arguments args = map(json_decode, args) # options args += map(lambda x: config.get(x), cmd.options) cmd_runner = Commands(config, wallet, self.network) cmd_runner.password = password func = getattr(cmd_runner, cmd.name) result = func(*args) return result def run(self): while self.is_running(): self.server.handle_request() os.unlink(lockfile(self.config)) def stop(self): for k, wallet in self.wallets.items(): wallet.stop_threads() DaemonThread.stop(self)
class Daemon(util.DaemonThread): def __init__(self, config, network, gui=None): util.DaemonThread.__init__(self) self.config = config self.network = network self.gui = gui self.wallets = {} if gui is None: self.wallet = self.load_wallet(config) else: self.wallet = None self.cmd_runner = Commands(self.config, self.wallet, self.network) host = config.get("rpchost", "localhost") port = config.get("rpcport", 7777) self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler, logRequests=False) self.server.socket.settimeout(1) for cmdname in known_commands: self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname) self.server.register_function(self.run_cmdline, "run_cmdline") self.server.register_function(self.ping, "ping") self.server.register_function(self.run_daemon, "daemon") self.server.register_function(self.run_gui, "gui") def ping(self): return True def run_daemon(self, config): sub = config.get("subcommand") assert sub in ["start", "stop", "status"] if sub == "start": response = "Daemon already running" elif sub == "status": p = self.network.get_parameters() response = { "path": self.network.config.path, "server": p[0], "blockchain_height": self.network.get_local_height(), "server_height": self.network.get_server_height(), "nodes": self.network.get_interfaces(), "connected": self.network.is_connected(), "auto_connect": p[4], "wallets": self.wallets.keys(), } elif sub == "stop": self.stop() response = "Daemon stopped" return response def run_gui(self, config_options): config = SimpleConfig(config_options) if self.gui: if hasattr(self.gui, "new_window"): path = config.get_wallet_path() self.gui.new_window(path, config.get("url")) response = "ok" else: response = "error: current GUI does not support multiple windows" else: response = "Error: Electrum is running in daemon mode. Please stop the daemon first." return response def load_wallet(self, config): path = config.get_wallet_path() if path in self.wallets: wallet = self.wallets[path] else: storage = WalletStorage(path) wallet = Wallet(storage) wallet.start_threads(self.network) self.wallets[path] = wallet return wallet def run_cmdline(self, config_options): password = config_options.get("password") config = SimpleConfig(config_options) cmdname = config.get("cmd") cmd = known_commands[cmdname] wallet = self.load_wallet(config) if cmd.requires_wallet else None if wallet: wallet.wait_until_synchronized() # arguments passed to function args = map(lambda x: config.get(x), cmd.params) # decode json arguments args = map(json_decode, args) # options args += map(lambda x: config.get(x), cmd.options) cmd_runner = Commands(config, wallet, self.network) cmd_runner.password = password func = getattr(cmd_runner, cmd.name) result = func(*args) return result def run(self): while self.is_running(): try: self.server.handle_request() except socket.timeout: continue except: break def stop(self): for k, wallet in self.wallets.items(): wallet.stop_threads() util.DaemonThread.stop(self)