pezkuwichain/pezkuwi-validator-v1.0.0
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-validator-v1.0.0.git synced 2026-04-21 23:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
pezkuwi-validator-v1.0.0/setup.sh
T

658 lines
20 KiB
Bash
Executable File
Raw Permalink Blame History

#!/bin/bash
# ========================================
# Pezkuwi Validator Setup Script v3.0.0
# ========================================
# Multi-network validator setup for distributed deployment
# Usage: sudo ./setup.sh <network> <validator_number>
# Example: sudo ./setup.sh beta_testnet 8
set -e
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# Function to print section headers
print_header() {
echo -e "\n${BLUE}========================================${NC}"
echo -e "${BLUE}$1${NC}"
echo -e "${BLUE}========================================${NC}\n"
}
# Function to check if a command exists
command_exists() {
command -v "$1" >/dev/null 2>&1
}
# Function to check dependency and display status
check_dependency() {
local cmd=$1
local name=$2
local version_cmd=$3
if command_exists "$cmd"; then
local version=$($version_cmd 2>&1 | head -n 1 || echo "unknown")
echo -e "${GREEN}✓${NC} $name: ${GREEN}Installed${NC} ($version)"
return 0
else
echo -e "${RED}✗${NC} $name: ${RED}Not installed${NC}"
return 1
fi
}
# Global variables for dependencies
missing_deps=()
RUST_MISSING=0
NODE_MISSING=0
# Parse and validate arguments
parse_arguments() {
print_header "Pezkuwi Validator Setup v3.0.0"
# Check if running with sudo
if [ "$EUID" -ne 0 ]; then
echo -e "${RED}Error: This script must be run with sudo${NC}"
echo "Usage: sudo ./setup.sh <network> <validator_number>"
exit 1
fi
# Check arguments
if [ $# -lt 2 ]; then
echo -e "${RED}Error: Missing arguments${NC}"
echo ""
echo "Usage: sudo ./setup.sh <network> <validator_number>"
echo ""
echo "Networks:"
echo " beta_testnet - Beta testnet (8 validators)"
echo " staging - Staging network (20 validators)"
echo " mainnet - Production network (100 validators)"
echo ""
echo "Example: sudo ./setup.sh beta_testnet 8"
exit 1
fi
NETWORK=$1
VALIDATOR_NUM=$2
# Validate network
case "$NETWORK" in
beta_testnet)
MAX_VALIDATORS=8
CHAIN_SPEC="pezkuwichain-beta-testnet"
;;
staging)
MAX_VALIDATORS=20
CHAIN_SPEC="pezkuwichain-staging"
;;
mainnet)
MAX_VALIDATORS=100
CHAIN_SPEC="pezkuwichain-mainnet"
;;
*)
echo -e "${RED}Error: Invalid network '$NETWORK'${NC}"
echo "Valid networks: beta_testnet, staging, mainnet"
exit 1
;;
esac
# Validate validator number
if ! [[ "$VALIDATOR_NUM" =~ ^[0-9]+$ ]]; then
echo -e "${RED}Error: Validator number must be a positive integer${NC}"
exit 1
fi
if [ "$VALIDATOR_NUM" -lt 1 ] || [ "$VALIDATOR_NUM" -gt "$MAX_VALIDATORS" ]; then
echo -e "${RED}Error: Validator number must be between 1 and $MAX_VALIDATORS for $NETWORK${NC}"
exit 1
fi
# Detect actual user (not root)
ACTUAL_USER=${SUDO_USER:-$USER}
ACTUAL_HOME=$(eval echo ~$ACTUAL_USER)
# Set paths
NETWORK_DIR="$SCRIPT_DIR/$NETWORK"
VALIDATOR_DIR="$NETWORK_DIR/validators/validator$VALIDATOR_NUM"
SDK_DIR="$ACTUAL_HOME/pezkuwi-sdk"
FRONTEND_DIR="$ACTUAL_HOME/DKSweb"
echo -e "${GREEN}Network:${NC} $NETWORK"
echo -e "${GREEN}Validator:${NC} $VALIDATOR_NUM / $MAX_VALIDATORS"
echo -e "${GREEN}User:${NC} $ACTUAL_USER"
echo -e "${GREEN}Home:${NC} $ACTUAL_HOME"
}
# Check system dependencies
check_dependencies() {
print_header "Checking System Dependencies"
missing_deps=()
# Essential build tools
if ! check_dependency "git" "Git" "git --version"; then
missing_deps+=("git")
fi
if ! check_dependency "curl" "Curl" "curl --version"; then
missing_deps+=("curl")
fi
if ! check_dependency "wget" "Wget" "wget --version"; then
missing_deps+=("wget")
fi
# Build essentials
if ! check_dependency "gcc" "GCC" "gcc --version"; then
missing_deps+=("build-essential")
fi
if ! check_dependency "make" "Make" "make --version"; then
missing_deps+=("build-essential")
fi
# Check pkg-config
if ! check_dependency "pkg-config" "pkg-config" "pkg-config --version"; then
missing_deps+=("pkg-config")
fi
# Check libssl-dev
if ! dpkg -l | grep -q libssl-dev; then
echo -e "${RED}✗${NC} libssl-dev: ${RED}Not installed${NC}"
missing_deps+=("libssl-dev")
else
echo -e "${GREEN}✓${NC} libssl-dev: ${GREEN}Installed${NC}"
fi
# Check clang
if ! check_dependency "clang" "Clang" "clang --version"; then
missing_deps+=("clang")
fi
# Check Rust
if ! su - $ACTUAL_USER -c 'command -v rustc' >/dev/null 2>&1; then
echo -e "${RED}✗${NC} Rust: ${RED}Not installed${NC}"
RUST_MISSING=1
else
local rust_version=$(su - $ACTUAL_USER -c 'rustc --version' 2>&1 | head -n 1)
echo -e "${GREEN}✓${NC} Rust: ${GREEN}Installed${NC} ($rust_version)"
RUST_MISSING=0
fi
# Check Cargo
if ! su - $ACTUAL_USER -c 'command -v cargo' >/dev/null 2>&1; then
RUST_MISSING=1
fi
# Check Node.js
if ! check_dependency "node" "Node.js" "node --version"; then
NODE_MISSING=1
else
NODE_MISSING=0
fi
# Check npm
if ! check_dependency "npm" "npm" "npm --version"; then
NODE_MISSING=1
fi
# Check systemd
if ! check_dependency "systemctl" "systemd" "systemctl --version"; then
echo -e "${YELLOW}Warning: systemd not found. Service management may not work.${NC}"
fi
# Check nginx
if ! check_dependency "nginx" "Nginx" "nginx -v"; then
missing_deps+=("nginx")
fi
}
# Install missing dependencies
install_dependencies() {
print_header "Installing Missing Dependencies"
echo "Updating package list..."
apt-get update
# Install system packages
if [ ${#missing_deps[@]} -gt 0 ]; then
echo -e "\n${YELLOW}Installing system packages:${NC} ${missing_deps[*]}"
apt-get install -y "${missing_deps[@]}"
echo -e "${GREEN}✓ System packages installed${NC}"
fi
# Install Rust if missing
if [ $RUST_MISSING -eq 1 ]; then
echo -e "\n${YELLOW}Installing Rust for user: $ACTUAL_USER${NC}"
echo "This may take a few minutes. Please wait..."
# Install Rust as the actual user
su - $ACTUAL_USER -c 'curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --verbose'
# Configure Rust toolchain
echo -e "\n${YELLOW}Configuring Rust toolchain...${NC}"
su - $ACTUAL_USER -c 'source $HOME/.cargo/env && rustup default stable'
su - $ACTUAL_USER -c 'source $HOME/.cargo/env && rustup update'
echo -e "\n${YELLOW}Adding WebAssembly target...${NC}"
su - $ACTUAL_USER -c 'source $HOME/.cargo/env && rustup target add wasm32-unknown-unknown'
echo -e "${GREEN}✓ Rust installed successfully for $ACTUAL_USER${NC}"
else
# Ensure wasm target is installed
echo -e "\n${YELLOW}Ensuring wasm32-unknown-unknown target...${NC}"
su - $ACTUAL_USER -c 'source $HOME/.cargo/env && rustup target add wasm32-unknown-unknown 2>/dev/null' || true
echo -e "${GREEN}✓ WebAssembly target verified${NC}"
fi
# Install Node.js if missing
if [ $NODE_MISSING -eq 1 ]; then
echo -e "\n${YELLOW}Installing Node.js...${NC}"
curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
apt-get install -y nodejs
echo -e "${GREEN}✓ Node.js installed${NC}"
fi
echo -e "\n${GREEN}✓ All dependencies installed!${NC}"
}
# Clone and build Pezkuwi SDK
setup_sdk() {
print_header "Setting up Pezkuwi SDK"
if [ -d "$SDK_DIR" ]; then
echo -e "${YELLOW}SDK directory already exists at $SDK_DIR${NC}"
echo -e "${YELLOW}Updating from GitHub...${NC}"
su - $ACTUAL_USER -c "cd $SDK_DIR && git fetch origin && git pull origin main"
else
echo "Cloning Pezkuwi SDK from GitHub..."
echo "This may take several minutes for initial clone..."
su - $ACTUAL_USER -c "cd $ACTUAL_HOME && git clone --depth 1 https://github.com/pezkuwichain/pezkuwi-sdk.git"
fi
echo -e "\n${YELLOW}Building Pezkuwi SDK (Release mode)...${NC}"
echo "This will take 15-30 minutes. Please be patient..."
echo ""
# Build as actual user with proper environment
su - $ACTUAL_USER -c "cd $SDK_DIR && source \$HOME/.cargo/env && cargo build --release"
echo -e "\n${GREEN}✓ Pezkuwi SDK built successfully${NC}"
echo "Binary location: $SDK_DIR/target/release/pezkuwi-node"
}
# Clone and build DKSweb frontend
setup_frontend() {
print_header "Setting up DKSweb Frontend"
if [ -d "$FRONTEND_DIR" ]; then
echo -e "${YELLOW}Frontend directory already exists at $FRONTEND_DIR${NC}"
echo -e "${YELLOW}Updating from GitHub...${NC}"
su - $ACTUAL_USER -c "cd $FRONTEND_DIR && git fetch origin && git pull origin main"
else
echo "Cloning DKSweb from GitHub..."
su - $ACTUAL_USER -c "cd $ACTUAL_HOME && git clone --depth 1 https://github.com/pezkuwichain/DKSweb.git"
fi
echo -e "\n${YELLOW}Installing frontend dependencies...${NC}"
su - $ACTUAL_USER -c "cd $FRONTEND_DIR && npm install"
echo -e "\n${YELLOW}Building frontend...${NC}"
su - $ACTUAL_USER -c "cd $FRONTEND_DIR && npm run build"
echo -e "\n${GREEN}✓ DKSweb frontend built successfully${NC}"
echo "Frontend build: $FRONTEND_DIR/dist"
}
# Get bootnode information for validators > 1
get_bootnode_info() {
if [ "$VALIDATOR_NUM" -eq 1 ]; then
echo -e "${GREEN}This is validator 1 (bootnode)${NC}"
BOOTNODE_ARG=""
return
fi
print_header "Bootnode Configuration"
echo -e "${YELLOW}This validator needs to connect to validator $((VALIDATOR_NUM - 1))${NC}"
echo ""
echo "Please obtain the bootnode multiaddr from validator $((VALIDATOR_NUM - 1))"
echo "The multiaddr format looks like:"
echo "/ip4/192.168.1.100/tcp/30333/p2p/12D3KooWAbCdEf..."
echo ""
read -p "Enter bootnode multiaddr (or press Enter to skip): " BOOTNODE_ADDR
if [ -n "$BOOTNODE_ADDR" ]; then
BOOTNODE_ARG="--bootnodes $BOOTNODE_ADDR"
echo -e "${GREEN}✓ Bootnode configured${NC}"
else
echo -e "${YELLOW}Warning: No bootnode specified. Node will run in isolation.${NC}"
BOOTNODE_ARG=""
fi
}
# Configure validator settings
configure_validator() {
print_header "Configuring Validator $VALIDATOR_NUM"
# Calculate ports
P2P_PORT=$((30333 + ($VALIDATOR_NUM - 1)))
RPC_PORT=$((9944 + ($VALIDATOR_NUM - 1)))
WS_PORT=$((9944 + ($VALIDATOR_NUM - 1)))
PROMETHEUS_PORT=$((9615 + ($VALIDATOR_NUM - 1)))
echo "Validator $VALIDATOR_NUM ports:"
echo " P2P Port: $P2P_PORT"
echo " RPC Port: $RPC_PORT"
echo " WebSocket Port: $WS_PORT"
echo " Prometheus Port: $PROMETHEUS_PORT"
# Create validator directories
mkdir -p "$VALIDATOR_DIR"/{config,data,keys,logs}
# Create validator config file
CONFIG_FILE="$VALIDATOR_DIR/config/validator.conf"
cat > "$CONFIG_FILE" << EOF
# Validator $VALIDATOR_NUM Configuration
# Network: $NETWORK
# Generated: $(date)
VALIDATOR_NUM=$VALIDATOR_NUM
VALIDATOR_NAME="validator-$VALIDATOR_NUM"
NETWORK=$NETWORK
CHAIN_SPEC=$CHAIN_SPEC
P2P_PORT=$P2P_PORT
RPC_PORT=$RPC_PORT
WS_PORT=$WS_PORT
PROMETHEUS_PORT=$PROMETHEUS_PORT
DATA_DIR=$VALIDATOR_DIR/data
KEYS_DIR=$VALIDATOR_DIR/keys
LOGS_DIR=$VALIDATOR_DIR/logs
SDK_PATH=$SDK_DIR
FRONTEND_PATH=$FRONTEND_DIR
ACTUAL_USER=$ACTUAL_USER
EOF
chown -R $ACTUAL_USER:$ACTUAL_USER "$VALIDATOR_DIR"
echo -e "${GREEN}✓ Configuration file created${NC}"
# Check for validator keys
KEYS_SCRIPT="$VALIDATOR_DIR/config/keys.sh"
if [ -f "$KEYS_SCRIPT" ]; then
echo -e "\n${GREEN}✓ Validator keys found${NC}"
echo "Keys file: $KEYS_SCRIPT"
else
echo -e "\n${YELLOW}Warning: No keys.sh found${NC}"
echo "You will need to add validator keys to: $KEYS_SCRIPT"
fi
}
# Setup systemd service
setup_service() {
print_header "Setting up Systemd Service"
SERVICE_NAME="pezkuwi-validator-$NETWORK-$VALIDATOR_NUM"
SERVICE_FILE="/etc/systemd/system/$SERVICE_NAME.service"
# Build node arguments
NODE_ARGS="--base-path $VALIDATOR_DIR/data"
NODE_ARGS="$NODE_ARGS --chain $CHAIN_SPEC"
NODE_ARGS="$NODE_ARGS --validator"
NODE_ARGS="$NODE_ARGS --name validator-$VALIDATOR_NUM"
NODE_ARGS="$NODE_ARGS --port $P2P_PORT"
NODE_ARGS="$NODE_ARGS --rpc-port $RPC_PORT"
NODE_ARGS="$NODE_ARGS --prometheus-port $PROMETHEUS_PORT"
NODE_ARGS="$NODE_ARGS --rpc-cors all"
NODE_ARGS="$NODE_ARGS --rpc-external"
NODE_ARGS="$NODE_ARGS --unsafe-force-node-key-generation"
if [ -n "$BOOTNODE_ARG" ]; then
NODE_ARGS="$NODE_ARGS $BOOTNODE_ARG"
fi
tee "$SERVICE_FILE" > /dev/null << EOF
[Unit]
Description=Pezkuwi Validator $VALIDATOR_NUM ($NETWORK)
After=network.target
[Service]
Type=simple
User=$ACTUAL_USER
WorkingDirectory=$VALIDATOR_DIR
EnvironmentFile=$VALIDATOR_DIR/config/validator.conf
ExecStart=$SDK_DIR/target/release/pezkuwi $NODE_ARGS
Restart=always
RestartSec=10
StandardOutput=append:$VALIDATOR_DIR/logs/validator.log
StandardError=append:$VALIDATOR_DIR/logs/validator-error.log
[Install]
WantedBy=multi-user.target
EOF
# Reload systemd
systemctl daemon-reload
echo -e "${GREEN}✓ Systemd service created${NC}"
echo "Service name: $SERVICE_NAME"
}
# Setup nginx for frontend
setup_nginx() {
print_header "Setting up Nginx"
NGINX_CONF="/etc/nginx/sites-available/pezkuwi-frontend"
if [ -f "$NGINX_CONF" ]; then
echo -e "${YELLOW}Nginx already configured${NC}"
echo "Skipping nginx setup..."
return
fi
tee "$NGINX_CONF" > /dev/null << EOF
server {
listen 80;
listen [::]:80;
server_name _;
root $FRONTEND_DIR/dist;
index index.html;
location / {
try_files \$uri \$uri/ /index.html;
}
location /api {
proxy_pass http://localhost:$RPC_PORT;
proxy_http_version 1.1;
proxy_set_header Upgrade \$http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host \$host;
}
}
EOF
# Enable site
ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/
# Remove default site if exists
rm -f /etc/nginx/sites-enabled/default
# Test nginx configuration
nginx -t
# Restart nginx
systemctl restart nginx
systemctl enable nginx
echo -e "${GREEN}✓ Nginx configured and restarted${NC}"
}
# Insert validator keys
insert_keys() {
KEYS_SCRIPT="$VALIDATOR_DIR/config/keys.sh"
if [ ! -f "$KEYS_SCRIPT" ]; then
echo -e "\n${YELLOW}Skipping key insertion - no keys.sh file found${NC}"
return
fi
print_header "Inserting Validator Keys"
# Source the keys
source "$KEYS_SCRIPT"
echo "Waiting for node to start..."
sleep 5
# Insert each key type
echo "Inserting BABE keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"babe\",\"$BABE_SEED\",\"$BABE_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo "Inserting GRANDPA keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"gran\",\"$GRAN_SEED\",\"$GRAN_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo "Inserting PARA keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"para\",\"$PARA_SEED\",\"$PARA_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo "Inserting ASGN keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"asgn\",\"$ASGN_SEED\",\"$ASGN_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo "Inserting AUDI keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"audi\",\"$AUDI_SEED\",\"$AUDI_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo "Inserting BEEF keys..."
curl -s -H "Content-Type: application/json" \
-d "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"author_insertKey\",\"params\":[\"beef\",\"$BEEF_SEED\",\"$BEEF_PUBLIC_KEY\"]}" \
http://127.0.0.1:$RPC_PORT > /dev/null
echo -e "${GREEN}✓ All keys inserted${NC}"
}
# Get peer ID for bootnode
get_peer_id() {
if [ "$VALIDATOR_NUM" -ne 1 ]; then
return
fi
print_header "Bootnode Information"
echo "Waiting for node to generate peer ID..."
sleep 10
echo -e "\n${GREEN}This is validator 1 (bootnode)${NC}"
echo "Other validators will need this information to connect."
echo ""
echo "To get your peer ID, check the validator logs:"
echo -e "${BLUE}tail -f $VALIDATOR_DIR/logs/validator.log${NC}"
echo ""
echo "Look for a line containing: 'Local node identity is: <PEER_ID>'"
echo ""
echo "Your bootnode multiaddr will be:"
echo "/ip4/<YOUR_IP>/tcp/$P2P_PORT/p2p/<PEER_ID>"
}
# Final instructions
show_final_instructions() {
print_header "Setup Complete!"
echo -e "${GREEN}Validator $VALIDATOR_NUM is ready!${NC}\n"
echo "Next steps:"
echo ""
echo "1. Start the validator:"
echo -e " ${BLUE}sudo systemctl start pezkuwi-validator-$NETWORK-$VALIDATOR_NUM${NC}"
echo ""
echo "2. Check validator status:"
echo -e " ${BLUE}sudo systemctl status pezkuwi-validator-$NETWORK-$VALIDATOR_NUM${NC}"
echo ""
echo "3. View logs:"
echo -e " ${BLUE}tail -f $VALIDATOR_DIR/logs/validator.log${NC}"
echo ""
echo "4. Enable auto-start on boot:"
echo -e " ${BLUE}sudo systemctl enable pezkuwi-validator-$NETWORK-$VALIDATOR_NUM${NC}"
echo ""
if [ "$VALIDATOR_NUM" -eq 1 ]; then
echo "5. Get bootnode peer ID:"
echo -e " ${BLUE}After starting, check logs for 'Local node identity'${NC}"
echo -e " ${BLUE}Share this with other validators${NC}"
echo ""
fi
echo "6. Access frontend:"
echo -e " ${BLUE}http://localhost${NC} (local)"
echo -e " ${BLUE}http://YOUR_SERVER_IP${NC} (network)"
echo ""
if [ ! -f "$VALIDATOR_DIR/config/keys.sh" ]; then
echo -e "${YELLOW}IMPORTANT: Add validator keys to:${NC}"
echo -e "${YELLOW}$VALIDATOR_DIR/config/keys.sh${NC}"
echo ""
fi
echo -e "${GREEN}Installation completed successfully!${NC}"
}
# Main function
main() {
# Parse and validate arguments
parse_arguments "$@"
# Check dependencies
check_dependencies || true
# Install missing dependencies
if [ ${#missing_deps[@]} -gt 0 ] || [ $RUST_MISSING -eq 1 ] || [ $NODE_MISSING -eq 1 ]; then
echo -e "\n${YELLOW}Installing missing dependencies...${NC}"
install_dependencies
else
echo -e "\n${GREEN}✓ All dependencies already installed${NC}"
fi
# Setup SDK
setup_sdk
# Setup frontend
setup_frontend
# Get bootnode info (for validators > 1)
get_bootnode_info
# Configure validator
configure_validator
# Setup systemd service
setup_service
# Setup nginx
setup_nginx
# Show final instructions
show_final_instructions
echo -e "\n${BLUE}========================================${NC}"
echo -e "${BLUE}Setup script completed${NC}"
echo -e "${BLUE}========================================${NC}\n"
}
# Run main function
main "$@"
Reference in New Issue View Git Blame Copy Permalink