def setUp(self):
super().setUp()
self.network = 'testnet'
self.manager = self.create_peer(self.network,
unlock_wallet=True,
wallet_index=True)
sendtokens_resource = SendTokensResource(self.manager)
sendtokens_resource.sleep_seconds = 0.1
self.web = StubSite(sendtokens_resource)
self.web_address_history = StubSite(
AddressHistoryResource(self.manager))
def register_resources(self, args: Namespace) -> None:
from hathor.conf import HathorSettings
from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource
from hathor.prometheus import PrometheusMetricsExporter
from hathor.resources import ProfilerResource
from hathor.transaction.resources import (
DashboardTransactionResource,
DecodeTxResource,
GraphvizLegacyResource,
GraphvizFullResource,
GraphvizNeighboursResource,
PushTxResource,
TipsHistogramResource,
TipsResource,
TransactionAccWeightResource,
TransactionResource,
)
from hathor.version_resource import VersionResource
from hathor.wallet.resources import (
AddressResource,
BalanceResource,
HistoryResource,
LockWalletResource,
SendTokensResource,
SignTxResource,
StateWalletResource,
UnlockWalletResource,
)
from hathor.wallet.resources.thin_wallet import (
AddressHistoryResource, SendTokensResource as
SendTokensThinResource, TokenHistoryResource, TokenResource)
from hathor.wallet.resources.nano_contracts import (
NanoContractDecodeResource,
NanoContractExecuteResource,
NanoContractMatchValueResource,
)
from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource
from hathor.stratum.resources import MiningStatsResource
settings = HathorSettings()
if args.prometheus:
kwargs: Dict[str, Any] = {'metrics': self.manager.metrics}
if args.data:
kwargs['path'] = os.path.join(args.data, 'prometheus')
else:
raise ValueError(
'To run prometheus exporter you must have a data path')
prometheus = PrometheusMetricsExporter(**kwargs)
prometheus.start()
if args.status:
# TODO get this from a file. How should we do with the factory?
root = Resource()
wallet_resource = Resource()
root.putChild(b'wallet', wallet_resource)
thin_wallet_resource = Resource()
root.putChild(b'thin_wallet', thin_wallet_resource)
contracts_resource = Resource()
wallet_resource.putChild(b'nano-contract', contracts_resource)
p2p_resource = Resource()
root.putChild(b'p2p', p2p_resource)
graphviz = GraphvizLegacyResource(self.manager)
# XXX: reach the resource through /graphviz/ too, previously it was a leaf so this wasn't a problem
graphviz.putChild(b'', graphviz)
for fmt in ['dot', 'pdf', 'png', 'jpg']:
bfmt = fmt.encode('ascii')
graphviz.putChild(
b'full.' + bfmt,
GraphvizFullResource(self.manager, format=fmt))
graphviz.putChild(
b'neighbours.' + bfmt,
GraphvizNeighboursResource(self.manager, format=fmt))
resources = (
(b'status', StatusResource(self.manager), root),
(b'version', VersionResource(self.manager), root),
(b'mining', MiningResource(self.manager), root),
(b'getmininginfo', MiningInfoResource(self.manager), root),
(b'decode_tx', DecodeTxResource(self.manager), root),
(b'push_tx', PushTxResource(self.manager), root),
(b'graphviz', graphviz, root),
(b'tips-histogram', TipsHistogramResource(self.manager), root),
(b'tips', TipsResource(self.manager), root),
(b'transaction', TransactionResource(self.manager), root),
(b'transaction_acc_weight',
TransactionAccWeightResource(self.manager), root),
(b'dashboard_tx', DashboardTransactionResource(self.manager),
root),
(b'profiler', ProfilerResource(self.manager), root),
# /thin_wallet
(b'address_history', AddressHistoryResource(self.manager),
thin_wallet_resource),
(b'send_tokens', SendTokensThinResource(self.manager),
thin_wallet_resource),
(b'token', TokenResource(self.manager), thin_wallet_resource),
(b'token_history', TokenHistoryResource(self.manager),
thin_wallet_resource),
# /wallet/nano-contract
(b'match-value', NanoContractMatchValueResource(self.manager),
contracts_resource),
(b'decode', NanoContractDecodeResource(self.manager),
contracts_resource),
(b'execute', NanoContractExecuteResource(self.manager),
contracts_resource),
# /p2p
(b'peers', AddPeersResource(self.manager), p2p_resource),
)
for url_path, resource, parent in resources:
parent.putChild(url_path, resource)
if self.manager.stratum_factory is not None:
root.putChild(b'miners', MiningStatsResource(self.manager))
if self.wallet and args.wallet_enable_api:
wallet_resources = (
# /wallet
(b'balance', BalanceResource(self.manager), wallet_resource
),
(b'history', HistoryResource(self.manager),
wallet_resource),
(b'address', AddressResource(self.manager),
wallet_resource),
(b'send_tokens', SendTokensResource(self.manager),
wallet_resource),
(b'sign_tx', SignTxResource(self.manager),
wallet_resource),
(b'unlock', UnlockWalletResource(self.manager),
wallet_resource),
(b'lock', LockWalletResource(self.manager),
wallet_resource),
(b'state', StateWalletResource(self.manager),
wallet_resource),
)
for url_path, resource, parent in wallet_resources:
parent.putChild(url_path, resource)
# Websocket resource
ws_factory = HathorAdminWebsocketFactory(
metrics=self.manager.metrics,
wallet_index=self.manager.tx_storage.wallet_index)
ws_factory.start()
resource = WebSocketResource(ws_factory)
root.putChild(b"ws", resource)
ws_factory.subscribe(self.manager.pubsub)
# Websocket stats resource
root.putChild(b'websocket_stats',
WebsocketStatsResource(ws_factory))
real_root = Resource()
real_root.putChild(settings.API_VERSION_PREFIX.encode('ascii'),
root)
status_server = server.Site(real_root)
reactor.listenTCP(args.status, status_server)
# Set websocket factory in metrics
self.manager.metrics.websocket_factory = ws_factory
def register_resources(self, args: Namespace) -> None:
from hathor.conf import HathorSettings
from hathor.debug_resources import (
DebugCrashResource,
DebugLogResource,
DebugMessAroundResource,
DebugPrintResource,
DebugRaiseResource,
DebugRejectResource,
)
from hathor.mining.ws import MiningWebsocketFactory
from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource
from hathor.profiler import get_cpu_profiler
from hathor.profiler.resources import CPUProfilerResource, ProfilerResource
from hathor.prometheus import PrometheusMetricsExporter
from hathor.transaction.resources import (
BlockAtHeightResource,
CreateTxResource,
DashboardTransactionResource,
DecodeTxResource,
GetBlockTemplateResource,
GraphvizFullResource,
GraphvizNeighboursResource,
MempoolResource,
PushTxResource,
SubmitBlockResource,
TransactionAccWeightResource,
TransactionResource,
TxParentsResource,
ValidateAddressResource,
)
from hathor.version_resource import VersionResource
from hathor.wallet.resources import (
AddressResource,
BalanceResource,
HistoryResource,
LockWalletResource,
SendTokensResource,
SignTxResource,
StateWalletResource,
UnlockWalletResource,
)
from hathor.wallet.resources.nano_contracts import (
NanoContractDecodeResource,
NanoContractExecuteResource,
NanoContractMatchValueResource,
)
from hathor.wallet.resources.thin_wallet import (
AddressBalanceResource,
AddressHistoryResource,
AddressSearchResource,
SendTokensResource as SendTokensThinResource,
TokenHistoryResource,
TokenResource,
)
from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource
settings = HathorSettings()
cpu = get_cpu_profiler()
if args.prometheus:
kwargs: Dict[str, Any] = {'metrics': self.manager.metrics}
if args.data:
kwargs['path'] = os.path.join(args.data, 'prometheus')
else:
raise ValueError('To run prometheus exporter you must have a data path')
prometheus = PrometheusMetricsExporter(**kwargs)
prometheus.start()
if args.status:
# TODO get this from a file. How should we do with the factory?
root = Resource()
wallet_resource = Resource()
root.putChild(b'wallet', wallet_resource)
thin_wallet_resource = Resource()
root.putChild(b'thin_wallet', thin_wallet_resource)
contracts_resource = Resource()
wallet_resource.putChild(b'nano-contract', contracts_resource)
p2p_resource = Resource()
root.putChild(b'p2p', p2p_resource)
graphviz = Resource()
# XXX: reach the resource through /graphviz/ too, previously it was a leaf so this wasn't a problem
graphviz.putChild(b'', graphviz)
for fmt in ['dot', 'pdf', 'png', 'jpg']:
bfmt = fmt.encode('ascii')
graphviz.putChild(b'full.' + bfmt, GraphvizFullResource(self.manager, format=fmt))
graphviz.putChild(b'neighbours.' + bfmt, GraphvizNeighboursResource(self.manager, format=fmt))
resources = [
(b'status', StatusResource(self.manager), root),
(b'version', VersionResource(self.manager), root),
(b'create_tx', CreateTxResource(self.manager), root),
(b'decode_tx', DecodeTxResource(self.manager), root),
(b'validate_address', ValidateAddressResource(self.manager), root),
(b'push_tx',
PushTxResource(self.manager, args.max_output_script_size, args.allow_non_standard_script),
root),
(b'graphviz', graphviz, root),
(b'transaction', TransactionResource(self.manager), root),
(b'block_at_height', BlockAtHeightResource(self.manager), root),
(b'transaction_acc_weight', TransactionAccWeightResource(self.manager), root),
(b'dashboard_tx', DashboardTransactionResource(self.manager), root),
(b'profiler', ProfilerResource(self.manager), root),
(b'top', CPUProfilerResource(self.manager, cpu), root),
(b'mempool', MempoolResource(self.manager), root),
# mining
(b'mining', MiningResource(self.manager), root),
(b'getmininginfo', MiningInfoResource(self.manager), root),
(b'get_block_template', GetBlockTemplateResource(self.manager), root),
(b'submit_block', SubmitBlockResource(self.manager), root),
(b'tx_parents', TxParentsResource(self.manager), root),
# /thin_wallet
(b'address_history', AddressHistoryResource(self.manager), thin_wallet_resource),
(b'address_balance', AddressBalanceResource(self.manager), thin_wallet_resource),
(b'address_search', AddressSearchResource(self.manager), thin_wallet_resource),
(b'send_tokens', SendTokensThinResource(self.manager), thin_wallet_resource),
(b'token', TokenResource(self.manager), thin_wallet_resource),
(b'token_history', TokenHistoryResource(self.manager), thin_wallet_resource),
# /wallet/nano-contract
(b'match-value', NanoContractMatchValueResource(self.manager), contracts_resource),
(b'decode', NanoContractDecodeResource(self.manager), contracts_resource),
(b'execute', NanoContractExecuteResource(self.manager), contracts_resource),
# /p2p
(b'peers', AddPeersResource(self.manager), p2p_resource),
]
if args.enable_debug_api:
debug_resource = Resource()
root.putChild(b'_debug', debug_resource)
resources.extend([
(b'log', DebugLogResource(), debug_resource),
(b'raise', DebugRaiseResource(), debug_resource),
(b'reject', DebugRejectResource(), debug_resource),
(b'print', DebugPrintResource(), debug_resource),
])
if args.enable_crash_api:
crash_resource = Resource()
root.putChild(b'_crash', crash_resource)
resources.extend([
(b'exit', DebugCrashResource(), crash_resource),
(b'mess_around', DebugMessAroundResource(self.manager), crash_resource),
])
for url_path, resource, parent in resources:
parent.putChild(url_path, resource)
if self.manager.stratum_factory is not None:
from hathor.stratum.resources import MiningStatsResource
root.putChild(b'miners', MiningStatsResource(self.manager))
with_wallet_api = bool(self.wallet and args.wallet_enable_api)
if with_wallet_api:
wallet_resources = (
# /wallet
(b'balance', BalanceResource(self.manager), wallet_resource),
(b'history', HistoryResource(self.manager), wallet_resource),
(b'address', AddressResource(self.manager), wallet_resource),
(b'send_tokens', SendTokensResource(self.manager), wallet_resource),
(b'sign_tx', SignTxResource(self.manager), wallet_resource),
(b'unlock', UnlockWalletResource(self.manager), wallet_resource),
(b'lock', LockWalletResource(self.manager), wallet_resource),
(b'state', StateWalletResource(self.manager), wallet_resource),
)
for url_path, resource, parent in wallet_resources:
parent.putChild(url_path, resource)
# Websocket resource
assert self.manager.tx_storage.indexes is not None
ws_factory = HathorAdminWebsocketFactory(metrics=self.manager.metrics,
address_index=self.manager.tx_storage.indexes.addresses)
ws_factory.start()
root.putChild(b'ws', WebSocketResource(ws_factory))
# Mining websocket resource
mining_ws_factory = MiningWebsocketFactory(self.manager)
root.putChild(b'mining_ws', WebSocketResource(mining_ws_factory))
ws_factory.subscribe(self.manager.pubsub)
# Websocket stats resource
root.putChild(b'websocket_stats', WebsocketStatsResource(ws_factory))
real_root = Resource()
real_root.putChild(settings.API_VERSION_PREFIX.encode('ascii'), root)
from hathor.profiler.site import SiteProfiler
status_server = SiteProfiler(real_root)
reactor.listenTCP(args.status, status_server)
self.log.info('with status', listen=args.status, with_wallet_api=with_wallet_api)
# Set websocket factory in metrics
self.manager.metrics.websocket_factory = ws_factory