mirror of
https://github.com/SChernykh/p2pool.git
synced 2024-08-18 12:38:46 -06:00
952 lines
33 KiB
Python
Executable File
952 lines
33 KiB
Python
Executable File
#!/bin/env python3
|
|
import sys
|
|
import time
|
|
import json
|
|
from jinja2 import Template
|
|
import npyscreen
|
|
|
|
# Help text in a box at the bottom of the screen
|
|
class HelpBoxBase(npyscreen.BoxTitle):
|
|
def splitlines(self):
|
|
all_help = []
|
|
for fld, msg in self.help_msgs.items():
|
|
if fld[-1] != ":":
|
|
fld += ":"
|
|
message = [m.lstrip() for m in msg if m != ""]
|
|
helpline = f"{fld:<28}{'. '.join(message)}"
|
|
all_help.append(helpline)
|
|
all_help.append("")
|
|
return all_help
|
|
|
|
def display_help_message(self, field):
|
|
self.set_values(
|
|
self.help_msgs.get(field, "No help availabe for {}".format(field))
|
|
)
|
|
self.clear()
|
|
self.display()
|
|
|
|
|
|
class P2PoolHelpBox(HelpBoxBase):
|
|
help_msgs = {
|
|
"Wallet Address:": [
|
|
"Your monero wallet address for receiving mining reqards",
|
|
"",
|
|
"Note: You have to use a primary wallet address for mining",
|
|
" Subaddresses and integrated addresses are not supported!",
|
|
],
|
|
"P2Pool Sidechain:": [
|
|
"Which P2Pool sidechain to mine on",
|
|
" use main for faster miners",
|
|
" use mini for slower miners",
|
|
],
|
|
"Enable Server Statistics": [
|
|
"Provide access to your P2Pool server statictics via a web interface",
|
|
],
|
|
"Statistics Port:": [
|
|
"Port number (or IP:Port) to expose web access to your P2Pool server",
|
|
"statictics",
|
|
],
|
|
"Expose Stratum Port": [
|
|
"Expose the P2Pool stratum port to your network so external miners",
|
|
"can connect",
|
|
"Note: You may choose to open this port in your hosts firewall and/or",
|
|
" router to allow miners outside your network to connect",
|
|
],
|
|
"Stratum Port:": [
|
|
"Port number (or IP:Port) to expose P2Pool stratum to your network to",
|
|
"allow external miners to connect",
|
|
"Note: You may choose to open this port in your hosts firewall and/or",
|
|
" router to allow miners outside your network to connect",
|
|
],
|
|
"P2Pool Log Level:": [
|
|
"Verbosity of the log; (Less) 0 - 6 (More)",
|
|
],
|
|
"Enable Autodiff": [
|
|
"Use automatic difficulty adjustment for miners connected to stratum",
|
|
],
|
|
"Enable Light Mode": [
|
|
"Don't allocate RandomX dataset, saves 2GB of RAM",
|
|
],
|
|
"Disable Cache": [
|
|
"Disable p2pool.cache (not recommended)",
|
|
],
|
|
"Additional P2Pool Options:": [
|
|
"Additional options to pass to p2pool commandline",
|
|
"",
|
|
"Note: Advanced - Only add options if you know what you are doing",
|
|
" See ouput of 'p2pool --help' for available options",
|
|
],
|
|
"Next": [
|
|
"Next configuration menu",
|
|
],
|
|
"Save": [
|
|
"Save current configuration and exit",
|
|
],
|
|
"Cancel": [
|
|
"Exit without saving",
|
|
],
|
|
}
|
|
|
|
|
|
class MoneroHelpBox(HelpBoxBase):
|
|
help_msgs = {
|
|
"Configure Monero Node": [
|
|
"Configure and run a Monero Node",
|
|
"",
|
|
"Note: You must either configure a local node or specify a public node",
|
|
],
|
|
"Monero Version:": [
|
|
"Version of Monero to build; 'latest' for the most recent release",
|
|
"",
|
|
"Note: Must be v0.17.3.0 or later for p2pool support",
|
|
" See: https://github.com/monero-project/monero/tags",
|
|
],
|
|
"Prune Blockchain": [
|
|
"Prune the Monero node to limit the size of the blockchain on disk",
|
|
],
|
|
"Monero Log Level:": [
|
|
"Verbosity of the log; (Less) 0 - 4 (More)",
|
|
"",
|
|
"Note: settings above 0 are very noisy",
|
|
],
|
|
"Expose RPC Port": [
|
|
"Expose restricted RPC API port to your network so external services",
|
|
"(wallets for example) can connect. Port 18083 (ZMQ-pub) will also be exposed.",
|
|
"Note: You may choose to open this port in your hosts firewall and/or",
|
|
" router to allow services outside your network to connect",
|
|
],
|
|
"RPC Port:": [
|
|
"TCP port to listen on for RPC connections",
|
|
],
|
|
"RPC Login:": [
|
|
"Specify username[:password] required to connect to the RPC API",
|
|
],
|
|
"Limit Data Rates": [
|
|
"Set a limit value for incoming and outgoing data transfer",
|
|
],
|
|
"Rate Limit Up:": [
|
|
"Set outgoing data transfer limit [kB/s]",
|
|
],
|
|
"Rate Limit Down:": [
|
|
"Set incoming data transfer limit [kB/s]",
|
|
],
|
|
"Sync Pruned Blocks": [
|
|
"Accept pruned blocks instead of pruning yourself to save",
|
|
"network transfer",
|
|
],
|
|
"Fast Block Sync": [
|
|
'Sync up most of the way by using embedded, "known" (old) block',
|
|
"hashes without calculating the block hash to verify the proof of work",
|
|
"",
|
|
"Note: Faster initial sync by trusting the monerod binary",
|
|
],
|
|
"Public Node:": [
|
|
"Public Monero Node to Use",
|
|
"",
|
|
"Note: The public node must have both Monero RPC and zmq-pub ports",
|
|
" available",
|
|
],
|
|
"Node Login:": [
|
|
"Specify username[:password] required to connect to public monero",
|
|
"node RPC API (if required)",
|
|
],
|
|
"Additional monerod Options:": [
|
|
"Additional options to pass to monerod commandline",
|
|
"",
|
|
"Note: Advanced - Only add options if you know what you are doing",
|
|
" See 'https://monerodocs.org/interacting/monerod-reference/'",
|
|
],
|
|
"Prev": [
|
|
"Previous configuration menu",
|
|
],
|
|
"Next": [
|
|
"Next configuration menu",
|
|
],
|
|
"Save": [
|
|
"Save current configuration and exit",
|
|
],
|
|
"Cancel": [
|
|
"Exit without saving",
|
|
],
|
|
}
|
|
|
|
|
|
class XMRigHelpBox(HelpBoxBase):
|
|
help_msgs = {
|
|
"Configure XMRig CPU Miner": [
|
|
"Configure and run an XMRig CPU Miner",
|
|
"",
|
|
"Note: You must either configure am XMRig CPU Miner or expose the",
|
|
" P2Pool stratum port and connect an external miner, or both",
|
|
],
|
|
"Username:": [
|
|
"Set a username for the miner",
|
|
],
|
|
"Use Fixed Difficulty": [
|
|
"Used a fixed minig difficulty",
|
|
"",
|
|
"Note: Allows you to see XMRig submitting shares below P2Pool threshold",
|
|
],
|
|
"Fixed Difficulty:": [
|
|
"Set a fixed mining difficulty",
|
|
"",
|
|
"Note: Allows you to see XMRig submitting shares below P2Pool threshold",
|
|
],
|
|
"CPU Use %:": [
|
|
"Maximum CPU threads count (in percentage) hint for autoconfig",
|
|
"Note: Applies to cores only. If you have HyperThreading enabled you",
|
|
" should divide this value by 2 (use 0-50%). Reference:",
|
|
" https://github.com/xmrig/xmrig/issues/1670#issuecomment-644433778",
|
|
],
|
|
"CPU Priority:": [
|
|
"Set process priority (0 idle, 2 normal to 5 highest)",
|
|
],
|
|
"Additional XMRig Options:": [
|
|
"Additional options to pass to xmrig",
|
|
"",
|
|
"Note: Advanced - Only add options if you know what you are doing",
|
|
" See 'https://xmrig.com/docs/miner/command-line-options'",
|
|
],
|
|
"Prev": [
|
|
"Previous configuration menu",
|
|
],
|
|
"Save": [
|
|
"Save current configuration and exit",
|
|
],
|
|
"Cancel": [
|
|
"Exit without saving",
|
|
],
|
|
}
|
|
|
|
|
|
##
|
|
# Custom (integer) values for title slider
|
|
class IntegerSlider(npyscreen.Slider):
|
|
def translate_value(self):
|
|
from_val = int(str(self.value).split(".")[0])
|
|
out_of_val = int(str(self.out_of).split(".")[0])
|
|
if from_val >= 1000:
|
|
from_val = str(from_val / 1000).split(".")[0] + "K"
|
|
out_of_val = str(out_of_val / 1000).split(".")[0] + "K"
|
|
return "{}/{}".format(from_val, out_of_val)
|
|
|
|
|
|
class TitleIntegerSlider(npyscreen.TitleSlider):
|
|
_entry_type = IntegerSlider
|
|
|
|
|
|
##
|
|
# Patched updateDependents for FormControlCheckbox
|
|
class PatchedFormControlCheckbox(npyscreen.FormControlCheckbox):
|
|
def updateDependents(self):
|
|
if self.value:
|
|
for w in self._visibleWhenSelected:
|
|
try:
|
|
w.fc_visible
|
|
except AttributeError:
|
|
w.fc_visible = {}
|
|
w.fc_visible[self.name] = True
|
|
for w in self._notVisibleWhenSelected:
|
|
try:
|
|
w.fc_visible
|
|
except AttributeError:
|
|
w.fc_visible = {}
|
|
w.fc_visible[self.name] = False
|
|
else:
|
|
for w in self._visibleWhenSelected:
|
|
try:
|
|
w.fc_visible
|
|
except AttributeError:
|
|
w.fc_visible = {}
|
|
w.fc_visible[self.name] = False
|
|
for w in self._notVisibleWhenSelected:
|
|
try:
|
|
w.fc_visible
|
|
except AttributeError:
|
|
w.fc_visible = {}
|
|
w.fc_visible[self.name] = True
|
|
for w in self._visibleWhenSelected + self._notVisibleWhenSelected:
|
|
w.hidden = False in w.fc_visible.values()
|
|
w.editable = not False in w.fc_visible.values()
|
|
self.parent.display()
|
|
|
|
def set_value(self, value):
|
|
self.value = value
|
|
self.display()
|
|
|
|
def display(self):
|
|
self.updateDependents()
|
|
super()
|
|
|
|
|
|
class PrevButton(npyscreen.Button):
|
|
def whenToggled(self):
|
|
self.value = False
|
|
self.parent.prev_form()
|
|
|
|
|
|
class NextButton(npyscreen.Button):
|
|
def whenToggled(self):
|
|
self.value = False
|
|
self.parent.next_form()
|
|
|
|
|
|
class SaveButton(npyscreen.Button):
|
|
def whenToggled(self):
|
|
self.find_parent_app().save_and_exit()
|
|
|
|
|
|
class CancelButton(npyscreen.Button):
|
|
def whenToggled(self):
|
|
self.find_parent_app().cancel_and_exit()
|
|
|
|
|
|
##
|
|
# Config Forms Base Class
|
|
class ConfigFormBase(npyscreen.FormBaseNew):
|
|
name_size = 20
|
|
indent = 5
|
|
current_config = None
|
|
defaults = None
|
|
ALLOW_RESIZE = False
|
|
|
|
def while_editing(self, arg):
|
|
self.help.display_help_message(arg.name)
|
|
self.display()
|
|
|
|
def get_default_config(self):
|
|
# Return defaults
|
|
if self.defaults is None:
|
|
with open("defaults") as defaults_file:
|
|
self.defaults = json.load(defaults_file)
|
|
return self.defaults
|
|
|
|
def get_current_config(self):
|
|
# Return current config
|
|
if self.current_config is None:
|
|
# Read current config
|
|
with open("/docker-compose/current_config") as current_config:
|
|
self.current_config = json.load(current_config)
|
|
return self.current_config
|
|
|
|
def reset_defaults(self, arg):
|
|
# Set config to default values
|
|
ok = npyscreen.notify_ok_cancel(
|
|
"Set current form values to defaults", title="Reset to Defaults"
|
|
)
|
|
if not ok:
|
|
return
|
|
defaults = self.get_default_config()
|
|
self.set_config(defaults)
|
|
|
|
|
|
##
|
|
# P2Pool Configuration Form
|
|
class P2PoolConfigForm(ConfigFormBase):
|
|
def create(self):
|
|
# Add Hot-Key Controls
|
|
self.add_handlers({"^D": self.reset_defaults})
|
|
# Add P2Pool Configuration
|
|
self.add(
|
|
npyscreen.TitleText,
|
|
name="## P2Pool Configuration",
|
|
editable=False,
|
|
begin_entry_at=50,
|
|
)
|
|
self.wallet_address = self.add(
|
|
npyscreen.TitleText,
|
|
name="Wallet Address:",
|
|
value="",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.sidechain = self.add(
|
|
npyscreen.TitleSelectOne,
|
|
name="P2Pool Sidechain:",
|
|
values=["main", "mini"],
|
|
scroll_exit=True,
|
|
max_height=2,
|
|
value=[
|
|
0,
|
|
],
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.enable_statistics = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Enable Server Statistics",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.statistics_port = self.add(
|
|
npyscreen.TitleText,
|
|
name="Statistics Port:",
|
|
value="3334",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.enable_statistics.addVisibleWhenSelected(self.statistics_port)
|
|
self.nextrely += 1
|
|
self.expose_stratum_port = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Expose Stratum Port",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.stratum_port = self.add(
|
|
npyscreen.TitleText,
|
|
name="Stratum Port:",
|
|
value="3333",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.expose_stratum_port.addVisibleWhenSelected(self.stratum_port)
|
|
self.nextrely += 1
|
|
self.p2pool_log_level = self.add(
|
|
TitleIntegerSlider,
|
|
name="P2Pool Log Level:",
|
|
out_of=6,
|
|
value=3,
|
|
lowest=0,
|
|
step=1,
|
|
width=43,
|
|
begin_entry_at=20,
|
|
label=True,
|
|
block_color=None,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.autodiff = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Enable Autodiff",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.light_mode = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Enable Light Mode",
|
|
value=False,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.no_cache = self.add(
|
|
npyscreen.Checkbox,
|
|
name="Disable Cache",
|
|
value=False,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.p2pool_extra = self.add(
|
|
npyscreen.TitleText,
|
|
name="Additional P2Pool Options:",
|
|
value="",
|
|
begin_entry_at=self.name_size + 10,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.nextrely += 1
|
|
# Add "Next", "Save", and "Cancel" buttons
|
|
self.next_button = self.add(NextButton, name="Next", relx=1)
|
|
self.nextrely -= 1
|
|
self.save_button = self.add(SaveButton, name="Save", relx=8)
|
|
self.nextrely -= 1
|
|
self.cancel_button = self.add(CancelButton, name="Cancel", relx=15)
|
|
self.nextrely += 1
|
|
# Add Help Box
|
|
self.help = self.add(
|
|
P2PoolHelpBox,
|
|
name="Commands: ^D: Load Defaults - ^C: Exit Without Saving",
|
|
values=[""],
|
|
editable=False,
|
|
)
|
|
# Start with current config
|
|
self.set_config(self.get_current_config())
|
|
|
|
def next_form(self):
|
|
self.find_parent_app().switchForm("MONERO")
|
|
|
|
def set_config(self, config):
|
|
self.wallet_address.set_value(config["wallet_address"])
|
|
self.sidechain.set_value(config["sidechain"])
|
|
self.enable_statistics.set_value(config["enable_statistics"])
|
|
self.statistics_port.set_value(config["statistics_port"])
|
|
self.expose_stratum_port.set_value(config["expose_stratum_port"])
|
|
self.stratum_port.set_value(config["stratum_port"])
|
|
self.p2pool_log_level.set_value(config["p2pool_log_level"])
|
|
self.autodiff.set_value(config["enable_autodiff"])
|
|
self.light_mode.set_value(config["light_mode"])
|
|
self.no_cache.value = config["no_cache"]
|
|
self.p2pool_extra.set_value(config["p2pool_options"])
|
|
self.DISPLAY()
|
|
|
|
def get_config(self):
|
|
config = {
|
|
"wallet_address": self.wallet_address.value,
|
|
"sidechain": self.sidechain.value,
|
|
"enable_statistics": self.enable_statistics.value,
|
|
"statistics_port": self.statistics_port.value,
|
|
"expose_stratum_port": self.expose_stratum_port.value,
|
|
"stratum_port": self.stratum_port.value,
|
|
"p2pool_log_level": self.p2pool_log_level.value,
|
|
"enable_autodiff": self.autodiff.value,
|
|
"light_mode": self.light_mode.value,
|
|
"no_cache": self.no_cache.value,
|
|
"p2pool_options": self.p2pool_extra.value,
|
|
}
|
|
return config
|
|
|
|
|
|
##
|
|
# Monero Configuration Form
|
|
class MoneroConfigForm(ConfigFormBase):
|
|
def create(self):
|
|
# Add Hot-Key Controls
|
|
self.add_handlers({"^D": self.reset_defaults})
|
|
# Add Monero Configuration
|
|
self.add(
|
|
npyscreen.TitleText,
|
|
name="## Monero Node Configuration",
|
|
editable=False,
|
|
begin_entry_at=50,
|
|
)
|
|
self.configure_monero_node = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Configure Monero Node",
|
|
value=True,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.monero_git_tag = self.add(
|
|
npyscreen.TitleText,
|
|
name="Monero Version:",
|
|
value="latest",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.monero_git_tag)
|
|
self.prune_node = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Prune Blockchain",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.prune_node)
|
|
self.monero_log_level = self.add(
|
|
TitleIntegerSlider,
|
|
name="Monero Log Level:",
|
|
out_of=4,
|
|
value=0,
|
|
lowest=0,
|
|
step=1,
|
|
width=43,
|
|
begin_entry_at=20,
|
|
label=True,
|
|
block_color=None,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.monero_log_level)
|
|
self.nextrely += 1
|
|
self.expose_rpc_port = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Expose RPC Port",
|
|
value=False,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.expose_rpc_port)
|
|
self.rpc_port = self.add(
|
|
npyscreen.TitleText,
|
|
name="RPC Port:",
|
|
value="18081",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.rpc_port)
|
|
self.expose_rpc_port.addVisibleWhenSelected(self.rpc_port)
|
|
self.rpc_login = self.add(
|
|
npyscreen.TitleText,
|
|
name="RPC Login:",
|
|
value="",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.expose_rpc_port.addVisibleWhenSelected(self.rpc_login)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.rpc_login)
|
|
self.nextrely += 1
|
|
self.limit_data_rates = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Limit Data Rates",
|
|
value=False,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.limit_data_rates)
|
|
self.rate_limit_up = self.add(
|
|
npyscreen.TitleText,
|
|
name="Rate Limit Up:",
|
|
value="2048",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.limit_data_rates.addVisibleWhenSelected(self.rate_limit_up)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.rate_limit_up)
|
|
self.rate_limit_down = self.add(
|
|
npyscreen.TitleText,
|
|
name="Rate Limit Down:",
|
|
value="8192",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.limit_data_rates.addVisibleWhenSelected(self.rate_limit_down)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.rate_limit_down)
|
|
self.nextrely += 1
|
|
self.sync_pruned_blocks = self.add(
|
|
npyscreen.Checkbox,
|
|
name="Sync Pruned Blocks",
|
|
value=False,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.sync_pruned_blocks)
|
|
self.prune_node.addVisibleWhenSelected(self.sync_pruned_blocks)
|
|
self.fast_sync = self.add(
|
|
npyscreen.Checkbox,
|
|
name="Fast Block Sync",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.fast_sync)
|
|
self.nextrely += 1
|
|
self.public_node = self.add(
|
|
npyscreen.TitleText,
|
|
name="Public Node:",
|
|
value="",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addInvisibleWhenSelected(self.public_node)
|
|
self.node_login = self.add(
|
|
npyscreen.TitleText,
|
|
name="Node Login:",
|
|
value="",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addInvisibleWhenSelected(self.node_login)
|
|
self.nextrely += 1
|
|
self.monero_extra = self.add(
|
|
npyscreen.TitleText,
|
|
name="Additional monerod Options:",
|
|
value="",
|
|
begin_entry_at=self.name_size + 10,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_monero_node.addVisibleWhenSelected(self.monero_extra)
|
|
self.nextrely += 1
|
|
self.nextrely += 1
|
|
# Add "Prev", "Next", "Save", and "Cancel" buttons
|
|
self.prev_button = self.add(PrevButton, name="Prev", relx=1)
|
|
self.nextrely -= 1
|
|
self.next_button = self.add(NextButton, name="Next", relx=8)
|
|
self.nextrely -= 1
|
|
self.save_button = self.add(SaveButton, name="Save", relx=15)
|
|
self.nextrely -= 1
|
|
self.cancel_button = self.add(CancelButton, name="Cancel", relx=22)
|
|
self.nextrely += 1
|
|
# Add Help Box
|
|
self.help = self.add(
|
|
MoneroHelpBox,
|
|
name="Commands: ^D: Load Defaults - ^C: Exit Without Saving",
|
|
values=[""],
|
|
editable=False,
|
|
)
|
|
# Start with current config
|
|
self.set_config(self.get_current_config())
|
|
|
|
def prev_form(self):
|
|
self.find_parent_app().switchForm("MAIN")
|
|
|
|
def next_form(self):
|
|
self.find_parent_app().switchForm("XMRIG")
|
|
|
|
def set_config(self, config):
|
|
self.configure_monero_node.set_value(config["configure_monero"])
|
|
self.monero_git_tag.set_value(config["monero_version"])
|
|
self.prune_node.value = config["prune_blockchain"]
|
|
self.monero_log_level.set_value(config["monero_log_level"])
|
|
self.expose_rpc_port.set_value(config["expose_rpc_port"])
|
|
self.rpc_port.set_value(config["rpc_port"])
|
|
self.rpc_login.set_value(config["rpc_login"])
|
|
self.limit_data_rates.set_value(config["limit_data_rates"])
|
|
self.rate_limit_up.set_value(config["rate_limit_up"])
|
|
self.rate_limit_down.set_value(config["rate_limit_down"])
|
|
self.sync_pruned_blocks.value = config["sync_pruned_blocks"]
|
|
self.fast_sync.value = config["fast_sync"]
|
|
self.monero_extra.set_value(config["monero_options"])
|
|
self.public_node.set_value(config["public_monero_node"])
|
|
self.node_login.set_value(config["monero_node_login"])
|
|
self.DISPLAY()
|
|
|
|
def get_config(self):
|
|
config = {
|
|
"configure_monero": self.configure_monero_node.value,
|
|
"monero_version": self.monero_git_tag.value,
|
|
"prune_blockchain": self.prune_node.value,
|
|
"monero_log_level": self.monero_log_level.value,
|
|
"expose_rpc_port": self.expose_rpc_port.value,
|
|
"rpc_port": self.rpc_port.value,
|
|
"rpc_login": self.rpc_login.value,
|
|
"limit_data_rates": self.limit_data_rates.value,
|
|
"rate_limit_up": self.rate_limit_up.value,
|
|
"rate_limit_down": self.rate_limit_down.value,
|
|
"sync_pruned_blocks": self.sync_pruned_blocks.value,
|
|
"fast_sync": self.fast_sync.value,
|
|
"monero_options": self.monero_extra.value,
|
|
"public_monero_node": self.public_node.value,
|
|
"monero_node_login": self.node_login.value,
|
|
}
|
|
return config
|
|
|
|
|
|
##
|
|
# XMRig Configuration Form
|
|
class XMRigConfigForm(ConfigFormBase):
|
|
def create(self):
|
|
# Add Hot-Key Controls
|
|
self.add_handlers({"^D": self.reset_defaults})
|
|
# Hidden caryover from P2Pool form
|
|
self.autodiff = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Enable Autodiff",
|
|
value=True,
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.autodiff.hide = True
|
|
self.autodiff.editable = False
|
|
self.nextrely -= 1
|
|
# Add XMRig Configuration
|
|
self.add(
|
|
npyscreen.TitleText,
|
|
name="## XMRig Miner Configuration",
|
|
editable=False,
|
|
begin_entry_at=50,
|
|
)
|
|
self.configure_xmrig_miner = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Configure XMRig CPU Miner",
|
|
value=True,
|
|
relx=self.indent,
|
|
)
|
|
self.nextrely += 1
|
|
self.username = self.add(
|
|
npyscreen.TitleText,
|
|
name="Username:",
|
|
value="",
|
|
begin_entry_at=self.name_size,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.username)
|
|
self.nextrely += 1
|
|
self.use_fixed_difficulty = self.add(
|
|
PatchedFormControlCheckbox,
|
|
name="Use Fixed Difficulty",
|
|
value=True,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.use_fixed_difficulty)
|
|
self.autodiff.addInvisibleWhenSelected(self.use_fixed_difficulty)
|
|
self.fixed_difficulty = self.add(
|
|
TitleIntegerSlider,
|
|
name="Fixed Difficulty:",
|
|
out_of=2000000,
|
|
value=500000,
|
|
lowest=50000,
|
|
step=50000,
|
|
width=51,
|
|
begin_entry_at=20,
|
|
label=True,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.fixed_difficulty)
|
|
self.use_fixed_difficulty.addVisibleWhenSelected(self.fixed_difficulty)
|
|
self.autodiff.addInvisibleWhenSelected(self.fixed_difficulty)
|
|
self.nextrely += 1
|
|
self.cpu_threads = self.add(
|
|
TitleIntegerSlider,
|
|
name="CPU Use %:",
|
|
out_of=100,
|
|
value=100,
|
|
lowest=1,
|
|
step=10,
|
|
width=48,
|
|
begin_entry_at=20,
|
|
label=True,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.cpu_threads)
|
|
self.nextrely += 1
|
|
self.cpu_priority = self.add(
|
|
TitleIntegerSlider,
|
|
name="CPU Priority:",
|
|
out_of=5,
|
|
value=2,
|
|
lowest=0,
|
|
step=1,
|
|
width=48,
|
|
begin_entry_at=20,
|
|
label=True,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.cpu_priority)
|
|
self.nextrely += 1
|
|
self.xmrig_extra = self.add(
|
|
npyscreen.TitleText,
|
|
name="Additional XMRig Options:",
|
|
value="",
|
|
begin_entry_at=self.name_size + 10,
|
|
relx=self.indent,
|
|
)
|
|
self.configure_xmrig_miner.addVisibleWhenSelected(self.xmrig_extra)
|
|
self.nextrely += 1
|
|
self.nextrely += 1
|
|
# Add "Prev", "Save", and "Cancel" buttons
|
|
self.prev_button = self.add(PrevButton, name="Prev", relx=1)
|
|
self.nextrely -= 1
|
|
self.save_button = self.add(SaveButton, name="Save", relx=8)
|
|
self.nextrely -= 1
|
|
self.cancel_button = self.add(CancelButton, name="Cancel", relx=15)
|
|
self.nextrely += 1
|
|
# Add Help Box
|
|
self.help = self.add(
|
|
XMRigHelpBox,
|
|
name="Commands: ^D: Load Defaults - ^C: Exit Without Saving",
|
|
values=[""],
|
|
editable=False,
|
|
)
|
|
# Start with current config
|
|
self.set_config(self.get_current_config())
|
|
|
|
def prev_form(self):
|
|
self.find_parent_app().switchForm("MONERO")
|
|
|
|
def next_form(self):
|
|
self.find_parent_app().switchForm(None)
|
|
|
|
def beforeEditing(self):
|
|
# Cary autodiff value from P2Pool config form
|
|
enable_autodiff = self.find_parent_app().get_p2pool_config()["enable_autodiff"]
|
|
self.autodiff.set_value(enable_autodiff)
|
|
|
|
def set_config(self, config):
|
|
self.configure_xmrig_miner.set_value(config["configure_xmrig"])
|
|
self.username.set_value(config["xmrig_username"])
|
|
self.use_fixed_difficulty.set_value(config["use_fixed_difficulty"])
|
|
self.fixed_difficulty.set_value(config["fixed_difficulty"])
|
|
self.cpu_threads.set_value(config["cpu_percent"])
|
|
self.cpu_priority.set_value(config["cpu_priority"])
|
|
self.xmrig_extra.set_value(config["xmrig_options"])
|
|
self.DISPLAY()
|
|
|
|
def get_config(self):
|
|
config = {
|
|
"configure_xmrig": self.configure_xmrig_miner.value,
|
|
"xmrig_username": self.username.value,
|
|
"use_fixed_difficulty": self.use_fixed_difficulty.value,
|
|
"fixed_difficulty": self.fixed_difficulty.value,
|
|
"cpu_percent": self.cpu_threads.value,
|
|
"cpu_priority": self.cpu_priority.value,
|
|
"xmrig_options": self.xmrig_extra.value,
|
|
}
|
|
return config
|
|
|
|
|
|
##
|
|
# Our P2Pool configuration App
|
|
class ConfigApp(npyscreen.NPSAppManaged):
|
|
current_config = None
|
|
defaults = None
|
|
|
|
def onStart(self):
|
|
self.p2pool_form = self.addForm(
|
|
"MAIN",
|
|
P2PoolConfigForm,
|
|
name="P2Pool for docker-compose: P2Pool Configuration",
|
|
minimum_lines=35,
|
|
minimum_columns=80,
|
|
)
|
|
self.monero_form = self.addForm(
|
|
"MONERO",
|
|
MoneroConfigForm,
|
|
name="P2Pool for docker-compose: Monero Configuration",
|
|
minimum_lines=35,
|
|
minimum_columns=80,
|
|
)
|
|
self.xmrig_form = self.addForm(
|
|
"XMRIG",
|
|
XMRigConfigForm,
|
|
name="P2Pool for docker-compose: XMRig Configuration",
|
|
minimum_lines=35,
|
|
minimum_columns=80,
|
|
)
|
|
|
|
def get_p2pool_config(self):
|
|
return self.p2pool_form.get_config()
|
|
|
|
def get_config(self):
|
|
p2pool_config = self.p2pool_form.get_config()
|
|
monero_config = self.monero_form.get_config()
|
|
xmrig_config = self.xmrig_form.get_config()
|
|
return p2pool_config | monero_config | xmrig_config
|
|
|
|
def save_and_exit(self):
|
|
# Get config from all forms
|
|
config = self.get_config()
|
|
# Save "current config" values file
|
|
with open("current_config.jinja2", "r") as current_config:
|
|
template = current_config.read()
|
|
rendered = Template(template).render(config)
|
|
with open("/docker-compose/current_config", "w") as current_config:
|
|
current_config.write(rendered)
|
|
# Render and save docker-compose file
|
|
with open("docker-compose.jinja2", "r") as compose_file:
|
|
template = compose_file.read()
|
|
rendered = Template(template).render(config, trim_blocks=True)
|
|
with open("/docker-compose/docker-compose.yml", "w") as compose_file:
|
|
compose_file.write(rendered)
|
|
npyscreen.notify("Saved current settings", title="Saved")
|
|
self.switchForm(None)
|
|
self.saved = True
|
|
|
|
def cancel_and_exit(self):
|
|
self.switchForm(None)
|
|
self.saved = False
|
|
|
|
|
|
##
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
time.sleep(1) # Give docker a second to initialize the terminal
|
|
App = ConfigApp()
|
|
App.run()
|
|
print("\n\n")
|
|
if App.saved:
|
|
print("Configuration Saved")
|
|
else:
|
|
print("Configuration Aborted")
|
|
sys.exit(1)
|
|
except KeyboardInterrupt:
|
|
print("Configuration Aborted")
|
|
sys.exit(1)
|