lukechilds
/
electrum
mirror of https://github.com/lukechilds/electrum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

merge jsonrpc gui and daemon

283
ThomasV 9 years ago
parent
e190024f73
commit
4682d95a76
4 changed files with 181 additions and 204 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 151
      electrum
  2. 72
      gui/jsonrpc.py
  3. 158
      lib/daemon.py
  4. 4
      lib/wallet.py

151
electrum
View File

@ -81,6 +81,7 @@ from electrum import SimpleConfig, Network, Wallet, WalletStorage
from electrum.util import print_msg, print_error, print_stderr, json_encode, json_decode, set_verbosity, InvalidPassword
from electrum.plugins import Plugins, run_hook, always_hook
from electrum.commands import get_parser, known_commands, Commands, config_variables
from electrum.daemon import Daemon, get_daemon
# get password routine
@ -233,138 +234,20 @@ def init_cmdline(config):
return cmd, password
def run_command(config, cmd, network, wallet, password):
if wallet and network:
wallet.wait_until_synchronized()
def run_offline_command(config, cmd, wallet, password):
# 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, network)
cmd_runner = Commands(config, wallet, None)
cmd_runner.password = password
func = getattr(cmd_runner, cmd.name)
result = func(*args)
return result
class ClientThread(util.DaemonThread):
def __init__(self, server, s):
util.DaemonThread.__init__(self)
self.server = server
self.client_pipe = util.SocketPipe(s)
self.network = self.server.network
def run(self):
config_options = self.client_pipe.get()
password = config_options.get('password')
config = SimpleConfig(config_options)
cmd = config.get('cmd')
if cmd == 'gui':
if self.server.gui:
if hasattr(server.gui, 'new_window'):
path = config.get_wallet_path()
self.server.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."
elif cmd == 'daemon':
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.server.wallets.keys(),
}
elif sub == 'stop':
self.server.stop()
response = "Daemon stopped"
else:
c = known_commands[cmd]
wallet = self.server.load_wallet(config) if c.requires_wallet else None
try:
response = run_command(config, c, self.network, wallet, password)
except BaseException as e:
err = traceback.format_exc()
response = {'error':err}
# send response and exit
self.client_pipe.send(response)
class NetworkServer(util.DaemonThread):
def __init__(self, config, network):
util.DaemonThread.__init__(self)
self.debug = False
self.config = config
self.pipe = util.QueuePipe()
self.network = network
self.lock = threading.RLock()
# gui is None is we run as daemon
self.gui = None
self.wallets = {}
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(self):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 0))
lockfile = os.path.join(self.config.path, 'lock')
with open(lockfile, 'w') as f:
f.write("%d"%s.getsockname()[1])
s.listen(5)
s.settimeout(0.1)
while self.is_running():
try:
connection, address = s.accept()
except socket.timeout:
continue
client = ClientThread(self, connection)
client.start()
print_error("Daemon exiting")
def stop(self):
for k, wallet in self.wallets.items():
wallet.stop_threads()
util.DaemonThread.stop(self)
def get_daemon(config):
lockfile = os.path.join(config.path, 'lock')
try:
with open(lockfile) as f:
num = int(f.read())
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('', num))
return s
except:
return False
if __name__ == '__main__':
# make sure that certificates are here
@ -441,20 +324,23 @@ if __name__ == '__main__':
wallet = Wallet(storage)
else:
wallet = None
result = run_command(config, cmd, None, wallet, password)
result = run_offline_command(config, cmd, wallet, password)
print_msg(json_encode(result))
sys.exit(0)
else:
config_options['password'] = password
# check if daemon is running
s = get_daemon(config)
if s:
p = util.SocketPipe(s)
p.set_timeout(1000000)
p.send(config_options)
result = p.get()
s.close()
server = get_daemon(config)
# daemon is running
if server is not None:
cmdname = config_options.get('cmd')
if cmdname == 'daemon':
result = server.daemon(config_options)
elif cmdname == 'gui':
result = server.gui(config_options)
else:
result = server.run_cmdline(config_options)
if type(result) in [str, unicode]:
print_msg(result)
elif type(result) is dict and result.get('error'):
@ -470,10 +356,13 @@ if __name__ == '__main__':
network.start()
else:
network = None
server = NetworkServer(config, network)
server = Daemon(config, network)
server.start()
server.gui = init_gui(config, network, plugins)
server.gui.main()
server.stop()
sys.exit(0)
elif cmd_name == 'daemon':
subcommand = config.get('subcommand')
if subcommand in ['status', 'stop']:
@ -484,7 +373,7 @@ if __name__ == '__main__':
if p == 0:
network = Network(config, plugins)
network.start()
server = NetworkServer(config, network)
server = Daemon(config, network)
if config.get('websocket_server'):
from electrum import websockets
websockets.WebSocketServer(config, network).start()

72
gui/jsonrpc.py
View File

@ -1,72 +0,0 @@
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2015 Thomas Voegtlin
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
jsonrpc interface for webservers.
may be called from your php script.
"""
import socket, os
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer, SimpleJSONRPCRequestHandler
from electrum.wallet import WalletStorage, Wallet
from electrum.commands import known_commands, Commands
class RequestHandler(SimpleJSONRPCRequestHandler):
def do_OPTIONS(self):
self.send_response(200)
self.end_headers()
def end_headers(self):
self.send_header("Access-Control-Allow-Headers",
"Origin, X-Requested-With, Content-Type, Accept")
self.send_header("Access-Control-Allow-Origin", "*")
SimpleJSONRPCRequestHandler.end_headers(self)
class ElectrumGui:
def __init__(self, config, network, plugins):
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):
self.wallet.start_threads(self.network)
while True:
try:
self.server.handle_request()
except socket.timeout:
continue
except:
break
self.wallet.stop_threads()

158
lib/daemon.py
View File

@ -0,0 +1,158 @@
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2015 Thomas Voegtlin
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import socket, os
import jsonrpclib
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer, SimpleJSONRPCRequestHandler
import util
from util import print_msg, print_error, print_stderr, json_encode, json_decode, set_verbosity, InvalidPassword
from wallet import WalletStorage, Wallet
from commands import known_commands, Commands
from simple_config import SimpleConfig
from network import Network
def get_daemon(config):
host = config.get('rpchost', 'localhost')
port = config.get('rpcport', 7777)
server = jsonrpclib.Server('http://%s:%d' % (host, port))
# check if daemon is running
try:
server.ping()
return server
except:
pass
class RequestHandler(SimpleJSONRPCRequestHandler):
def do_OPTIONS(self):
self.send_response(200)
self.end_headers()
def end_headers(self):
self.send_header("Access-Control-Allow-Headers",
"Origin, X-Requested-With, Content-Type, Accept")
self.send_header("Access-Control-Allow-Origin", "*")
SimpleJSONRPCRequestHandler.end_headers(self)
class Daemon(util.DaemonThread):
def __init__(self, config, network):
util.DaemonThread.__init__(self)
self.config = config
self.network = network
self.wallets = {}
self.wallet = self.load_wallet(config)
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.daemon, 'daemon')
self.server.register_function(self.gui, 'gui')
def ping(self):
return True
def 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 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)

4
lib/wallet.py
View File

@ -118,7 +118,9 @@ class WalletStorage(PrintError):
self.write()
def write(self):
assert not threading.currentThread().isDaemon()
if threading.currentThread().isDaemon():
self.print_error('warning: daemon thread cannot write wallet')
return
if not self.modified:
return
s = json.dumps(self.data, indent=4, sort_keys=True)

Write Preview
Loading…
Cancel
Save