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